fix(ai): resolve the ONNX wasm directory against the app, not the route

packages/ai/babel.config.js

@@ -0,0 +1 @@
+module.exports = require('../../babel.config.js');

packages/ai/jest.config.js

@@ -0,0 +1,18 @@
+/* eslint-disable */
+const base = require('../../jest.config.base.js');
+const path = require('path');
+
+module.exports = {
+  ...base,
+  displayName: 'ai',
+  testMatch: [
+    ...base.testMatch,
+    '<rootDir>/src/**/*.test.ts',
+    '<rootDir>/src/**/*.spec.ts',
+  ],
+  moduleNameMapper: {
+    ...base.moduleNameMapper,
+    '^@cornerstonejs/(\\w+)/(.+)$': path.resolve(__dirname, '../$1/src/$2'),
+    '^@cornerstonejs/(.*)$': path.resolve(__dirname, '../$1/src'),
+  },
+};

packages/ai/src/ONNXSegmentationController.ts

@@ -14,6 +14,7 @@ import {
   LabelmapBaseTool,
 } from '@cornerstonejs/tools';
 import { Events as aiEvents } from './enums';
+import getOrtWasmPaths from './utils/getOrtWasmPaths';
 
 const { strategies } = cstSegmentation;
 const { fillInsideCircle } = strategies;
@@ -1641,7 +1642,13 @@ export default class ONNXSegmentationController {
     }
     config.threads = parseInt(String(config.threads));
     config.local = parseInt(config.local);
-    ort.env.wasm.wasmPaths = 'ort/';
+    // Leave a location the application assigned alone. Otherwise take the
+    // system-level wasm directory, or resolve the copy of
+    // `onnxruntime-web/dist` against the application rather than against the
+    // current route. See `getOrtWasmPaths`.
+    if (!ort.env.wasm.wasmPaths) {
+      ort.env.wasm.wasmPaths = getOrtWasmPaths();
+    }
     ort.env.wasm.numThreads = config.threads;
     ort.env.wasm.proxy = config.provider == 'wasm';
 

packages/ai/src/index.ts

@@ -2,10 +2,19 @@ import ONNXSegmentationController from './ONNXSegmentationController';
 import LabelmapSlicePropagationTool from './LabelmapSlicePropagationTool';
 import MarkerLabelmapTool from './MarkerLabelmapTool';
 import { Events } from './enums';
+import getOrtWasmPaths, {
+  DEFAULT_ORT_WASM_DIRECTORY,
+} from './utils/getOrtWasmPaths';
 
 export {
   ONNXSegmentationController,
   LabelmapSlicePropagationTool,
   MarkerLabelmapTool,
   Events,
+  // Exported to answer where the ONNX Runtime binaries will be looked for, not
+  // to configure it: the location comes from `init({ wasmBasePath })` on the
+  // DICOM image loader, from `PUBLIC_URL`, or from assigning
+  // `ort.env.wasm.wasmPaths` directly, which the controller leaves alone.
+  getOrtWasmPaths,
+  DEFAULT_ORT_WASM_DIRECTORY,
 };

packages/ai/src/utils/getOrtWasmPaths.test.ts

@@ -0,0 +1,49 @@
+import { utilities } from '@cornerstonejs/core';
+import getOrtWasmPaths from './getOrtWasmPaths';
+
+/**
+ * How a base is resolved is `resolveWasmBasePath` in `@cornerstonejs/core`,
+ * covered by `packages/core/test/wasmBasePath.jest.js`. What is left here is the
+ * one thing this module decides - the standard directory - and that the two ways
+ * an application declares a location both reach the ONNX Runtime.
+ */
+describe('getOrtWasmPaths', () => {
+  const publicUrl = process.env.PUBLIC_URL;
+
+  beforeEach(() => {
+    delete (globalThis as { PUBLIC_URL?: string }).PUBLIC_URL;
+    delete process.env.PUBLIC_URL;
+    utilities.setWasmBasePath(undefined);
+    window.history.replaceState(null, '', '/');
+  });
+
+  afterAll(() => {
+    if (publicUrl === undefined) {
+      delete process.env.PUBLIC_URL;
+    } else {
+      process.env.PUBLIC_URL = publicUrl;
+    }
+  });
+
+  it('looks in ort/ under the application base', () => {
+    process.env.PUBLIC_URL = '/pacs/';
+    // The bug this guards: `'ort/'` used to resolve against the route, so a
+    // viewer on /pacs/viewer/dicomweb fetched /pacs/viewer/ort/ and got
+    // index.html back.
+    window.history.replaceState(null, '', '/pacs/viewer/dicomweb');
+
+    expect(getOrtWasmPaths()).toBe('http://localhost/pacs/ort/');
+  });
+
+  it('loads from the configured wasm directory, the way the codecs do', () => {
+    utilities.setWasmBasePath('/assets/cs-wasm/');
+
+    expect(getOrtWasmPaths()).toBe('http://localhost/assets/cs-wasm/');
+  });
+
+  it('serves the binaries from a CDN the configured directory names', () => {
+    utilities.setWasmBasePath('https://cdn.example.com/wasm/');
+
+    expect(getOrtWasmPaths()).toBe('https://cdn.example.com/wasm/');
+  });
+});

packages/ai/src/utils/getOrtWasmPaths.ts

@@ -0,0 +1,47 @@
+/**
+ * ONNX Runtime fetches its WebAssembly binaries from the prefix held in
+ * `ort.env.wasm.wasmPaths` and feeds whatever comes back straight to
+ * `WebAssembly.instantiateStreaming`.
+ *
+ * Every other wasm binary in this repository is located with
+ * `new URL(<specifier>, import.meta.url)` — the bundler resolves the file,
+ * emits it, and hands back an absolute URL that does not depend on the page the
+ * user is currently on. `onnxruntime-web@1.17` cannot be addressed that way:
+ * its `exports` map publishes only the JavaScript entry points, so
+ * `new URL('onnxruntime-web/dist/ort-wasm-simd.jsep.wasm', import.meta.url)`
+ * fails to resolve. Applications copy `onnxruntime-web/dist` somewhere they
+ * serve instead — the example runner copies it to `<example>/ort`
+ * (`utils/ExampleRunner/template-config.js`) — and point the runtime there.
+ *
+ * That makes it the same problem the codec binaries have, and it gets the same
+ * answer: `utilities.resolveWasmBasePath` in `@cornerstonejs/core`, which
+ * prefers the wasm directory the application declared and otherwise resolves
+ * the standard directory against the application's base. All this module adds
+ * is the standard directory name.
+ *
+ * Those two are the whole story, and there is deliberately no third way to name
+ * the location here. Since the binaries cannot be reached from this module,
+ * there is nothing to fall back to: an application serving them from somewhere
+ * else says so with `init({ wasmBasePath })`, or declares where it is mounted
+ * with `PUBLIC_URL`, or assigns `ort.env.wasm.wasmPaths` itself — which the
+ * controller leaves alone.
+ *
+ * When `onnxruntime-web` is eventually bumped to >= 1.21 its
+ * `*.bundle.min.mjs` builds resolve their own `.wasm` through `import.meta.url`
+ * and this module can be deleted.
+ */
+import { utilities } from '@cornerstonejs/core';
+
+/** Directory applications copy `onnxruntime-web/dist` into. */
+export const DEFAULT_ORT_WASM_DIRECTORY = 'ort/';
+
+/**
+ * Absolute URL prefix for the ONNX Runtime wasm binaries: the wasm directory the
+ * application configured, or `ort/` under the application's base.
+ *
+ * @returns the prefix as an absolute URL, or the directory unchanged when there
+ *   is nothing to resolve it against (a non-browser context).
+ */
+export default function getOrtWasmPaths(): string {
+  return utilities.resolveWasmBasePath(DEFAULT_ORT_WASM_DIRECTORY);
+}

packages/ai/tsconfig.json

@@ -4,5 +4,6 @@
     "outDir": "./dist/esm",
     "rootDir": "./src"
   },
-  "include": ["./src/**/*"]
+  "include": ["./src/**/*"],
+  "exclude": ["./src/**/*.spec.ts", "./src/**/*.test.ts"]
 }

packages/core/src/utilities/index.ts

@@ -140,6 +140,12 @@ import {
   viewportIsInStackMode,
 } from './viewportCapabilities';
 import { getNormalizedAspectRatio } from './getNormalizedAspectRatio';
+import {
+  getWasmBasePath,
+  resolveWasmBasePath,
+  setWasmBasePath,
+} from './wasmBasePath';
+import resolveApplicationUrl, { getPublicUrl } from './resolveApplicationUrl';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport: IViewport, volumeId?: string) =>
   _getViewportModality(viewport, volumeId, cache.getVolume);
@@ -276,4 +282,9 @@ export {
   viewportIsInVolumeMode,
   viewportIsInStackMode,
   getNormalizedAspectRatio,
+  getWasmBasePath,
+  setWasmBasePath,
+  resolveWasmBasePath,
+  resolveApplicationUrl,
+  getPublicUrl,
 };

packages/core/src/utilities/resolveApplicationUrl.ts

@@ -0,0 +1,100 @@
+/**
+ * Resolves a path against the base the *application* is served from, rather
+ * than against the current document.
+ *
+ * A document-relative path resolves against the current route, so it only finds
+ * what it is looking for while the page happens to sit at the right depth. An
+ * application served from `/viewer/dicomweb` that asks for `assets/x` requests
+ * `/viewer/assets/x` and receives whatever the SPA fallback answers with, which
+ * for a binary asset means a corrupt file rather than an error. Anything an
+ * application stores beside its bundle and fetches by name — wasm binaries
+ * above all, since `WebAssembly.instantiateStreaming` reports the resulting
+ * `index.html` as a magic-word failure — has to be resolved against the
+ * application instead.
+ *
+ * `PUBLIC_URL` is where that base comes from: the value an application already
+ * injects to say where it is mounted, defaulting to the server root.
+ */
+
+/**
+ * Declared because `process` does not exist in a browser, and the bundlers that
+ * substitute `process.env.PUBLIC_URL` do it by matching that exact expression —
+ * so it has to be spelled out rather than reached through `globalThis`.
+ */
+declare const process: { env: Record<string, string | undefined> };
+
+/** Base assumed when nothing declares one: applications sit at the root. */
+export const DEFAULT_PUBLIC_URL = '/';
+
+/**
+ * `PUBLIC_URL` as a build-time substitution (Create React App and friends).
+ *
+ * A `typeof process !== 'undefined'` guard would be the obvious way to write
+ * this and does not work: bundlers rewrite `process.env.PUBLIC_URL` but leave
+ * the `typeof` check alone, and it is false in every browser bundle, so the
+ * substituted value would never be read. Catching the reference error is what
+ * is left.
+ */
+function getBuildTimePublicUrl(): string | undefined {
+  try {
+    return process.env.PUBLIC_URL || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The base the application declares for itself, defaulting to the server root.
+ *
+ * `PUBLIC_URL` on the global is the runtime spelling
+ * `utils/demo/helpers/initDemo.ts` sets and `dicom-microscopy-viewer` reads;
+ * `config.path` is the same value carried in a viewer's configuration object.
+ */
+export function getPublicUrl(): string {
+  const globals = globalThis as {
+    PUBLIC_URL?: string;
+    config?: { path?: string };
+  };
+
+  return (
+    globals.PUBLIC_URL ||
+    globals.config?.path ||
+    getBuildTimePublicUrl() ||
+    DEFAULT_PUBLIC_URL
+  );
+}
+
+/**
+ * The page's origin, and nothing else. `PUBLIC_URL` is usually a path
+ * (`/pacs/`) and needs something absolute to resolve against, but the route is
+ * exactly what must stay out of the result — so hand over the protocol and host
+ * alone rather than `location.href` or `document.baseURI`.
+ */
+function getOrigin(): string | undefined {
+  const { location } = globalThis;
+
+  return location ? `${location.protocol}//${location.host}` : undefined;
+}
+
+/**
+ * Resolves a path against the application's base.
+ *
+ * @param path - a relative path is relative to the application, an absolute
+ *   path is relative to the server root, and a full URL (a CDN) is used as
+ *   given. An empty path yields the application's base itself.
+ * @returns an absolute URL, or `path` unchanged when there is nothing to
+ *   resolve it against (a non-browser context).
+ */
+export default function resolveApplicationUrl(path = ''): string {
+  const publicUrl = getPublicUrl();
+  // `PUBLIC_URL=/pacs` is a common spelling, and URL resolution would treat
+  // that last segment as a file name and discard it.
+  const base = publicUrl.endsWith('/') ? publicUrl : `${publicUrl}/`;
+  const origin = getOrigin();
+
+  try {
+    return new URL(path, origin ? new URL(base, origin) : new URL(base)).href;
+  } catch {
+    return path;
+  }
+}

packages/core/src/utilities/wasmBasePath.ts

@@ -0,0 +1,66 @@
+/**
+ * Where Cornerstone loads its WebAssembly binaries from.
+ *
+ * A wasm binary cannot be located the way a bundled asset is. The usual
+ * `new URL(<specifier>, import.meta.url)` only works when the bundler resolves,
+ * emits and hashes the file, and several of the binaries Cornerstone needs
+ * cannot be reached that way: the decoders name their codecs with bare
+ * `@cornerstonejs/codec-...` specifiers, which bundlers do not rewrite inside
+ * `new URL(...)`, and `onnxruntime-web@1.17` publishes only JavaScript entry
+ * points in its `exports` map. An application therefore copies those binaries
+ * somewhere it serves and *declares* where they are.
+ *
+ * Declaring it once is the point of `wasmBasePath`: one directory holding every
+ * binary, set through `init({ wasmBasePath })` on
+ * `@cornerstonejs/dicom-image-loader` (see `LoaderOptions.wasmBasePath`) and
+ * recorded here rather than privately in the loader, so that every package
+ * locating a binary honours the same directory.
+ *
+ * When nothing declares one, each set of binaries falls back to the standard
+ * directory its owner copies them into, resolved against the application rather
+ * than against the current document — see `resolveApplicationUrl` for why that
+ * distinction is the whole point.
+ */
+import resolveApplicationUrl from './resolveApplicationUrl';
+
+/** Directory every wasm binary is loaded from, or undefined for the default. */
+let wasmBasePath: string | undefined;
+
+/**
+ * Sets the directory every wasm binary is loaded from. Pass undefined (or an
+ * empty string) to restore each consumer's own default resolution.
+ *
+ * `init({ wasmBasePath })` on `@cornerstonejs/dicom-image-loader` calls this,
+ * so applications configuring the loader do not need to call it themselves.
+ */
+export function setWasmBasePath(basePath?: string): void {
+  wasmBasePath = basePath || undefined;
+}
+
+/** The configured wasm directory, or undefined when nothing has set one. */
+export function getWasmBasePath(): string | undefined {
+  return wasmBasePath;
+}
+
+/**
+ * Absolute URL of the directory a set of wasm binaries loads from.
+ *
+ * @param defaultDirectory - directory to use when nothing has declared one: the
+ *   standard location its owner copies the binaries into, e.g. `ort/` for the
+ *   ONNX Runtime. Both it and a configured `wasmBasePath` are resolved the same
+ *   way — relative to the application, or to the server root when absolute, or
+ *   used as given when a full URL.
+ * @returns the directory as an absolute URL with a trailing slash, or the
+ *   unresolved directory when there is nothing to resolve it against (a
+ *   non-browser context).
+ */
+export function resolveWasmBasePath(defaultDirectory = ''): string {
+  const directory = wasmBasePath || defaultDirectory;
+
+  // A trailing slash, so the value resolves as a directory rather than having
+  // its last segment discarded as a file name. An empty directory stays empty:
+  // it resolves to the application's base itself, not to the server root.
+  return resolveApplicationUrl(
+    !directory || directory.endsWith('/') ? directory : `${directory}/`
+  );
+}