@loaders.gl/core 5.0.0-alpha.1 → 5.0.0-alpha.11

package/src/lib/api/load-loader.ts

@@ -2,7 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import {isSourceLoader, mergeOptions} from '@loaders.gl/loader-utils';
+import type {
+  Loader,
+  LoaderOptions,
+  LoaderWithParser,
+  StrictLoaderOptions
+} from '@loaders.gl/loader-utils';
 
 const loaderImplementationPromises = new Map<Loader, Map<string, Promise<LoaderWithParser>>>();
 const loaderImplementations = new Map<Loader, Map<string, LoaderWithParser>>();
@@ -13,6 +19,15 @@ export async function getLoaderImplementation(
   options?: LoaderOptions,
   url?: string
 ): Promise<LoaderWithParser> {
+  if (isSourceLoader(loader)) {
+    const source = loader.preload ? await loader.preload(url || '', options) : loader;
+    if (!isSourceLoader(source)) {
+      throw new Error(
+        `${loader.id} source loader preload() did not return a runtime source loader`
+      );
+    }
+    return source as unknown as LoaderWithParser;
+  }
   if (isLoaderWithParser(loader)) {
     return loader;
   }
@@ -57,6 +72,11 @@ export async function getLoaderImplementation(
 
 /** Gets a cached parser-bearing implementation for a loader without loading it. */
 export function getLoaderImplementationSync(loader: Loader): LoaderWithParser | null {
+  if (loader.subloaders && !preparedLoaders.has(loader)) {
+    const prepared = preparedDefaults.get(loader);
+    if (prepared) return prepared;
+    if (!isLoaderWithParser(loader)) return null;
+  }
   if (isLoaderWithParser(loader)) {
     return loader;
   }
@@ -121,20 +141,9 @@ function getLoaderImplementationSpecifier(loader: Loader, options?: LoaderOption
 
 /** Gets the cache key for option-selected parser implementations. */
 function getLoaderImplementationCacheKey(loader: Loader, options?: LoaderOptions): string {
-  const loaderOptions = options?.[loader.id] as
-    | {backend?: unknown; implementation?: unknown}
-    | undefined;
+  const loaderOptions = options?.[loader.id] as {backend?: unknown} | undefined;
   const defaultLoaderOptions = loader.options?.[loader.id] as {backend?: unknown} | undefined;
-  return String(
-    loaderOptions?.backend ||
-      getDeprecatedImplementationBackend(loaderOptions?.implementation) ||
-      defaultLoaderOptions?.backend ||
-      ''
-  );
-}
-
-function getDeprecatedImplementationBackend(implementation: unknown): unknown {
-  return implementation === 'js' ? 'typescript' : implementation;
+  return String(loaderOptions?.backend || defaultLoaderOptions?.backend || '');
 }
 
 /** Imports a module and finds the parser-bearing loader implementation with the requested id. */
@@ -161,3 +170,137 @@ async function importLoaderImplementation(
     `Could not find parser implementation for ${loaderId} in ${implementationSpecifier}`
   );
 }
+
+/** Prepared loaders carry caller-local parser bindings rather than shared metadata. */
+const preparedLoaders = new WeakSet<Loader>();
+/** Successfully prepared default graphs used by synchronous parsing. */
+const preparedDefaults = new WeakMap<Loader, LoaderWithParser>();
+/** In-flight preparations for default dependency graphs. */
+const subloaderPreparations = new WeakMap<Loader, Promise<LoaderWithParser>>();
+
+/** Resolves declared dependencies and binds parser entry points to their implementations. */
+export async function preloadLoaderDependencies(
+  loader: Loader,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser> {
+  if (preparedLoaders.has(loader)) return await getLoaderImplementation(loader, options, url);
+  validateSubloaderGraph(loader, options);
+  return await prepareLoaderDependencies(loader, options, url);
+}
+
+/** Prepares a node after the complete dependency graph has been validated. */
+async function prepareLoaderDependencies(
+  loader: Loader,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser> {
+  // Options can select nested backends or overrides; do not share their bindings.
+  if (!options) {
+    const cached = subloaderPreparations.get(loader);
+    if (cached) return await cached;
+  }
+  const preparation = bindSubloaders(loader, options, url);
+  if (!options) {
+    subloaderPreparations.set(loader, preparation);
+    void preparation.catch(() => subloaderPreparations.delete(loader));
+  }
+  const prepared = await preparation;
+  if (!options) preparedDefaults.set(loader, prepared);
+  return prepared;
+}
+
+/** Returns declared dependencies with the shared flat override map applied. */
+function getSubloaders(loader: Loader, options?: LoaderOptions): Record<string, Loader> {
+  const overrides = options?.core?.subloaders || {};
+  return Object.fromEntries(
+    Object.entries(loader.subloaders || {}).map(([name, dependency]) => [
+      name,
+      Object.hasOwn(overrides, name) ? overrides[name] : dependency
+    ])
+  );
+}
+
+/** Rejects cycles in the dependency graph after applying the shared overrides. */
+function validateSubloaderGraph(loader: Loader, options?: LoaderOptions): void {
+  visitLoader(loader, []);
+
+  /** Detects cycles along each resolved dependency path. */
+  function visitLoader(currentLoader: Loader, ancestors: Loader[]): void {
+    if (ancestors.includes(currentLoader)) {
+      throw new Error(
+        `Subloader cycle: ${[...ancestors, currentLoader].map(value => value.id).join(' -> ')}`
+      );
+    }
+    for (const dependency of Object.values(getSubloaders(currentLoader, options))) {
+      visitLoader(dependency, [...ancestors, currentLoader]);
+    }
+  }
+}
+
+/** Prepares dependencies concurrently and injects them into parser calls' scoped options. */
+async function bindSubloaders(
+  loader: Loader,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser> {
+  const [implementation, entries] = await Promise.all([
+    getLoaderImplementation(loader, options, url),
+    Promise.all(
+      Object.entries(getSubloaders(loader, options)).map(
+        async ([name, dependency]) =>
+          [name, await prepareLoaderDependencies(dependency, options, url)] as const
+      )
+    )
+  ]);
+  const subloaders = Object.fromEntries(entries);
+  // Expose preload settings as defaults before core normalizes a later parse call.
+  const defaultOptions = mergeOptions(
+    implementation.options,
+    (options || {}) as StrictLoaderOptions
+  );
+  defaultOptions.core = {...defaultOptions.core, worker: false};
+  const prepared = {...implementation, options: defaultOptions, subloaders};
+  delete prepared.preload;
+  // Function-valued dependency bindings cannot be transferred to a worker.
+  prepared.worker = false;
+  for (const method of [
+    'parseBlob',
+    'createDataSource',
+    'parse',
+    'parseSync',
+    'parseText',
+    'parseTextSync',
+    'parseInBatches',
+    'parseFile',
+    'parseFileInBatches',
+    'parseUrl'
+  ] as const) {
+    const parser = (implementation as Record<string, unknown>)[method];
+    if (typeof parser === 'function') {
+      (prepared as Record<string, unknown>)[method] = (
+        data: unknown,
+        parseOptions?: LoaderOptions,
+        context?: unknown
+      ) => {
+        const forwardedOptions = mergeOptions(options, parseOptions || {});
+        return parser.call(
+          implementation,
+          data,
+          {
+            ...forwardedOptions,
+            core: {
+              ...forwardedOptions.core,
+              subloaders: options?.core?.subloaders || parseOptions?.core?.subloaders,
+              worker: false
+            },
+            [loader.id]: {...(forwardedOptions[loader.id] as object), subloaders}
+          },
+          context
+        );
+      };
+    }
+  }
+  preparedLoaders.add(prepared);
+  return prepared;
+}

package/src/lib/api/load.ts

@@ -13,12 +13,25 @@ import type {
   LoaderReturnType,
   LoaderArrayOptionsType,
   LoaderArrayReturnType,
-  SourceLoader
+  SourceLoader,
+  SourcePropsType,
+  SourceArrayOptionsType,
+  DataSourceOptions,
+  LoaderWithParser
+} from '@loaders.gl/loader-utils';
+import {
+  isBlob,
+  isSourceLoader,
+  resolveAuthenticationOptions,
+  resolveLoaderAuthenticationOptions
 } from '@loaders.gl/loader-utils';
-import {isBlob, isSourceLoader} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {getFetchFunction} from '../loader-utils/get-fetch-function';
-import {normalizeLoaderOptions} from '../loader-utils/option-utils';
+import {
+  applySearchParamsToUrl,
+  normalizeLoaderOptions,
+  getGlobalLoaderOptions
+} from '../loader-utils/option-utils';
 import {fetchFile} from '../fetch/fetch-file';
 
 import {parse} from './parse';
@@ -27,6 +40,7 @@ import {parseSync} from './parse-sync';
 import {parseInBatches} from './parse-in-batches';
 import {loadInBatches} from './load-in-batches';
 import {selectLoader} from './select-loader';
+import {getLoaderImplementation} from './load-loader';
 
 /**
  * Parses `data` using a specified loader
@@ -47,7 +61,7 @@ export async function load<
 >(
   url: string | DataType,
   loader: LoaderT,
-  options?: OptionsT,
+  options?: LoaderT extends SourceLoader ? SourcePropsType<LoaderT> & DataSourceOptions : OptionsT,
   context?: LoaderContext
 ): Promise<LoaderReturnType<LoaderT>>;
 
@@ -57,7 +71,7 @@ export async function load<
 >(
   url: string | DataType,
   loaders: LoaderArrayT,
-  options?: OptionsT,
+  options?: LoaderArrayT extends SourceLoader[] ? SourceArrayOptionsType<LoaderArrayT> : OptionsT,
   context?: LoaderContext
 ): Promise<LoaderArrayReturnType<LoaderArrayT>>;
 
@@ -93,7 +107,15 @@ export async function load(
     resolvedOptions = options as LoaderOptions;
   }
 
+  resolvedOptions ||= getGlobalLoaderOptions();
+
   if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
+    resolvedOptions = await resolveLoaderAuthenticationOptions(
+      resolvedLoaders.getAuthentications ? resolvedLoaders : sourceLoader,
+      typeof url === 'string' ? url : '',
+      resolvedOptions || {}
+    );
     const runtimeCoreApi = {
       fetchFile,
       parse,
@@ -103,7 +125,7 @@ export async function load(
       load,
       loadInBatches
     };
-    return resolvedLoaders.createDataSource(
+    return sourceLoader.createDataSource(
       url as string | Blob,
       (resolvedOptions || {}) as LoaderOptionsType<SourceLoader>,
       runtimeCoreApi
@@ -115,6 +137,12 @@ export async function load(
     resolvedLoaders.length === 1 &&
     isSourceLoader(resolvedLoaders[0])
   ) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
+    resolvedOptions = await resolveLoaderAuthenticationOptions(
+      resolvedLoaders[0].getAuthentications ? resolvedLoaders[0] : sourceLoader,
+      typeof url === 'string' ? url : '',
+      resolvedOptions || {}
+    );
     const runtimeCoreApi = {
       fetchFile,
       parse,
@@ -124,7 +152,7 @@ export async function load(
       load,
       loadInBatches
     };
-    return resolvedLoaders[0].createDataSource(
+    return sourceLoader.createDataSource(
       url as string | Blob,
       (resolvedOptions || {}) as LoaderOptionsType<SourceLoader>,
       runtimeCoreApi
@@ -138,7 +166,13 @@ export async function load(
     });
 
     if (selectedLoader && isSourceLoader(selectedLoader)) {
-      return selectedLoader.createDataSource(
+      const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(
+        selectedLoader.getAuthentications ? selectedLoader : sourceLoader,
+        typeof url === 'string' ? url : '',
+        resolvedOptions || {}
+      );
+      return sourceLoader.createDataSource(
         url,
         (resolvedOptions || {}) as LoaderOptionsType<SourceLoader>,
         {
@@ -152,16 +186,43 @@ export async function load(
         }
       );
     }
+
+    if (selectedLoader && typeof url === 'string') {
+      const loaderImplementation = await getLoaderImplementation(
+        selectedLoader,
+        resolvedOptions,
+        url
+      );
+      resolvedOptions = await resolveLoaderAuthenticationOptions(
+        selectedLoader.getAuthentications ? selectedLoader : loaderImplementation,
+        url,
+        resolvedOptions || {}
+      );
+      const parseUrl = (
+        loaderImplementation as LoaderWithParser & {
+          parseUrl?: (
+            url: string,
+            options?: LoaderOptions,
+            context?: LoaderContext
+          ) => Promise<unknown>;
+        }
+      ).parseUrl;
+      if (parseUrl) {
+        const requestUrl = applySearchParamsToUrl(url, resolvedOptions);
+        return await parseUrl(requestUrl, resolvedOptions, context);
+      }
+    }
   }
 
   // Select fetch function
+  if (resolvedOptions) resolvedOptions = resolveAuthenticationOptions(resolvedOptions);
   const fetch = getFetchFunction(resolvedOptions);
 
   // at this point, `url` could be already loaded binary data
   let data = url;
   // url is a string, fetch the url
   if (typeof url === 'string') {
-    data = await fetch(url);
+    data = await fetch(applySearchParamsToUrl(url, resolvedOptions));
     // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)
   }
 
@@ -190,3 +251,20 @@ export async function load(
     ? await parse(data, resolvedLoaders, resolvedOptions, context) // loader array overload
     : await parse(data, resolvedLoaders, resolvedOptions, context); // single loader overload
 }
+
+/** Resolves a lightweight source loader into its runtime implementation when necessary. */
+async function resolveSourceLoader(
+  loader: SourceLoader,
+  url: string | DataType,
+  options?: LoaderOptions
+): Promise<SourceLoader> {
+  if (!loader.preload) {
+    return loader;
+  }
+
+  const sourceLoader = await loader.preload(typeof url === 'string' ? url : '', options);
+  if (!isSourceLoader(sourceLoader)) {
+    throw new Error(`${loader.id} source loader preload() did not return a runtime source loader`);
+  }
+  return sourceLoader;
+}

package/src/lib/api/parse-file.ts

@@ -16,7 +16,11 @@ import type {
   ReadableFile,
   StrictLoaderOptions
 } from '@loaders.gl/loader-utils';
-import {isSourceLoader, mergeOptions} from '@loaders.gl/loader-utils';
+import {
+  isSourceLoader,
+  mergeOptions,
+  resolveLoaderAuthenticationOptions
+} from '@loaders.gl/loader-utils';
 import {validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
@@ -96,7 +100,16 @@ export async function parseFile(
   }
 
   // @ts-expect-error candidateLoaders may be a single forced loader
-  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const authenticationLoader =
+    !loader.getAuthentications && normalizedOptions.core?.credentials?.length
+      ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url)
+      : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(
+    authenticationLoader,
+    url,
+    normalizedOptions
+  );
   context = getLoaderContext(
     // @ts-expect-error candidateLoaders may be a single forced loader
     {url, _parse: parse, loaders: candidateLoaders},

package/src/lib/api/parse-in-batches.ts

@@ -4,6 +4,7 @@
 
 import type {Batch} from '@loaders.gl/schema';
 import {isTable, makeBatchFromTable} from '@loaders.gl/schema-utils';
+import {resolveLoaderAuthenticationOptions} from '@loaders.gl/loader-utils';
 import type {
   Loader,
   LoaderWithParser,
@@ -19,7 +20,12 @@ import type {
   LoaderArrayBatchType,
   TransformBatches
 } from '@loaders.gl/loader-utils';
-import {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
+import {
+  canParseWithWorker,
+  concatenateArrayBuffersAsync,
+  isBrowser,
+  parseWithWorkerInBatches
+} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
 import {getLoaderContext} from '../loader-utils/loader-context';
@@ -107,7 +113,16 @@ export async function parseInBatches(
   }
 
   // Normalize options
-  const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+  const normalizedOptions = normalizeOptions(options, loader, loaderArray, url);
+  const authenticationLoader =
+    !loader.getAuthentications && normalizedOptions.core?.credentials?.length
+      ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url)
+      : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(
+    authenticationLoader,
+    url || '',
+    normalizedOptions
+  );
   context = getLoaderContext(
     {url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray},
     strictOptions,
@@ -177,8 +192,12 @@ async function parseToOutputIterator(
     options?.core?.transforms || []
   );
 
-  // If loader supports parseInBatches, we are done
+  // Stream supported browser batch parsers through one stateful worker session.
   if (loader.parseInBatches) {
+    // The loader-level adapter is intentionally piloted with CSV Arrow batches first.
+    if (loader.id === 'csv' && isBrowser && canParseWithWorker(loader, options)) {
+      return parseWithWorkerInBatches(loader, transformedIterator, options, context, parse);
+    }
     return loader.parseInBatches(transformedIterator, options, context);
   }
 

package/src/lib/api/parse.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {resolveLoaderAuthenticationOptions} from '@loaders.gl/loader-utils';
 import type {
   Loader,
   LoaderContext,
@@ -18,9 +19,10 @@ import type {
 } from '@loaders.gl/loader-utils';
 import {
   parseWithWorker,
-  canParseWithWorker,
+  shouldParseWithWorker,
   mergeOptions,
   isResponse,
+  isBlob,
   isSourceLoader
 } from '@loaders.gl/loader-utils';
 import {validateWorkerVersion} from '@loaders.gl/worker-utils';
@@ -120,7 +122,16 @@ export async function parse(
 
   // Normalize options
   // @ts-expect-error candidateLoaders
-  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
+  const authenticationLoader =
+    !loader.getAuthentications && normalizedOptions.core?.credentials?.length
+      ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url)
+      : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(
+    authenticationLoader,
+    url || '',
+    normalizedOptions
+  );
 
   // Get a context (if already present, will be unchanged)
   context = getLoaderContext(
@@ -155,11 +166,15 @@ async function parseWithLoader(
 
   const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
 
-  if (canParseWithWorker(loaderWithParser, options)) {
+  if (shouldParseWithWorker(loaderWithParser, data, options, context, loader)) {
     data = await getArrayBufferFromData(data, options);
     return await parseWithWorker(loaderWithParser, data, options, context, parse);
   }
 
+  if (isBlob(data) && loaderWithParser.parseBlob) {
+    return await loaderWithParser.parseBlob(data, options, context);
+  }
+
   data = await getArrayBufferOrStringFromData(data, loader, options);
 
   return await parseWithLoaderImplementation(loaderWithParser, data, options, context);

package/src/lib/api/preload.ts

@@ -2,13 +2,23 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
-import {getLoaderImplementation, getLoaderImplementationSync} from './load-loader';
+import type {Loader, LoaderOptions, LoaderWithParser, SourceLoader} from '@loaders.gl/loader-utils';
+import {
+  getLoaderImplementation,
+  getLoaderImplementationSync,
+  preloadLoaderDependencies
+} from './load-loader';
 
 /**
- * Preloads a loader implementation so later parse/load calls do not pay the resolution cost on first use.
- * May return a parser-bearing loader that also supports `parseSync`.
+ * Prepares a source implementation and its declared dependencies before source creation.
  */
+export async function preload<SourceT extends SourceLoader>(
+  loader: SourceT,
+  options?: LoaderOptions,
+  url?: string
+): Promise<SourceT>;
+
+/** Prepares a parser and its recursively declared dependencies. */
 export async function preload<LoaderT extends Loader>(
   loader: LoaderT,
   options?: LoaderOptions,
@@ -19,13 +29,18 @@ export async function preload(
   loader: Loader,
   options?: LoaderOptions,
   url?: string
-): Promise<LoaderWithParser> {
-  return await getLoaderImplementation(loader, options, url);
+): Promise<LoaderWithParser | SourceLoader> {
+  return loader.subloaders
+    ? await preloadLoaderDependencies(loader, options, url)
+    : await getLoaderImplementation(loader, options, url);
 }
 
 /**
  * Returns a cached parser-bearing loader implementation if one is already available.
  */
-export function preloadSync(loader: Loader): LoaderWithParser | null {
+export function preloadSync<SourceT extends SourceLoader>(loader: SourceT): SourceT | null;
+/** Returns a cached parser, including prepared default dependency bindings. */
+export function preloadSync(loader: Loader): LoaderWithParser | null;
+export function preloadSync(loader: Loader): LoaderWithParser | SourceLoader | null {
   return getLoaderImplementationSync(loader);
 }

package/src/lib/filesystems/browser-filesystem.ts

@@ -50,23 +50,34 @@ export class BrowserFileSystem implements FileSystem {
     }
 
     // Local fetches are served from the list of files
-    const file = this.files[path];
+    const file = this._getFile(path, true);
     if (!file) {
       return new Response(path, {status: 400, statusText: 'NOT FOUND'});
     }
 
     const headers = new Headers(options?.headers);
     const range = headers.get('Range');
-    const bytes = range && /bytes=($1)-($2)/.exec(range);
+    const bytes = range && /bytes=(\d+)-(\d+)/.exec(range);
 
     if (bytes) {
       const start = parseInt(bytes[1]);
-      const end = parseInt(bytes[2]);
+      const end = Math.min(parseInt(bytes[2]), file.size - 1);
+      if (start > end) {
+        const response = new Response(null, {
+          status: 416,
+          headers: {'Content-Range': `bytes */${file.size}`}
+        });
+        Object.defineProperty(response, 'url', {value: path});
+        return response;
+      }
       // The trick when reading File objects is to read successive "slices" of the File
       // Per spec https://w3c.github.io/FileAPI/, slicing a File should only update the start and end fields
       // Actually reading from file should happen in `readAsArrayBuffer` (and as far we can tell it does)
-      const data = await file.slice(start, end).arrayBuffer();
-      const response = new Response(data);
+      const data = await file.slice(start, end + 1).arrayBuffer();
+      const response = new Response(data, {
+        status: 206,
+        headers: {'Content-Range': `bytes ${start}-${end}/${file.size}`}
+      });
       Object.defineProperty(response, 'url', {value: path});
       return response;
     }
@@ -95,7 +106,7 @@ export class BrowserFileSystem implements FileSystem {
    * Return information (size) about files in this file system
    */
   async stat(path: string, options?: object): Promise<{size: number}> {
-    const file = this.files[path];
+    const file = this._getFile(path, false);
     if (!file) {
       throw new Error(path);
     }
@@ -106,16 +117,19 @@ export class BrowserFileSystem implements FileSystem {
    * Just removes the file from the list
    */
   async unlink(path: string): Promise<void> {
-    delete this.files[path];
-    delete this.lowerCaseFiles[path];
-    this.usedFiles[path] = true;
+    const file = this._getFile(path, false);
+    if (file) {
+      delete this.files[file.name];
+      delete this.lowerCaseFiles[file.name.toLowerCase()];
+      this.usedFiles[file.name] = true;
+    }
   }
 
   // implements IRandomAccessFileSystem
 
   // RANDOM ACCESS
   async openReadableFile(pathname: string, flags: unknown): Promise<ReadableFile> {
-    return new BlobFile(this.files[pathname]);
+    return new BlobFile(this._getFile(pathname, true));
   }
 
   // PRIVATE
@@ -123,7 +137,7 @@ export class BrowserFileSystem implements FileSystem {
   // Supports case independent paths, and file usage tracking
   _getFile(path: string, used: boolean): File {
     // Prefer case match, but fall back to case independent.
-    const file = this.files[path] || this.lowerCaseFiles[path];
+    const file = this.files[path] || this.lowerCaseFiles[path.toLowerCase()];
     if (file && used) {
       this.usedFiles[path] = true;
     }