@@ -19,7 +19,8 @@
 
 ## Architecture — read this before editing
 
-- **One real module per algorithm** under `src/<module>/<module>.ts`, each extending the base class in **`src/core/core.ts`** (constants, data-type helpers, the shared cache). `src/jsfeatNext.ts` is a thin aggregator that only attaches modules to the namespace; `src/index.ts` default-exports the namespace directly.
+- **One real module per algorithm** under `src/<module>/<module>.ts`, each extending the base class in **`src/core/core.ts`** (constants, data-type helpers, the shared cache). `src/jsfeatNext.ts` is a thin aggregator that builds the namespace; `src/index.ts` default-exports the namespace directly and also exports every member by name (#137). The algorithm singletons are created once in `src/singletons.ts`, shared by both. The UMD bundle is built from `src/umd.ts` (namespace only), the ESM bundle from `src/index.ts`.
+  - **Keep the bundle tree-shakeable (#137).** The namespace is a subclass of the `core` base, built in one `/* @__PURE__ */ Object.assign(...)`, never by assigning members one by one, and every module-level `new` (singletons, shared helper instances, typed-array tables) is marked `/* @__PURE__ */`. An unannotated one silently puts its module back into every bundle; `tests/build/bundle.test.ts` catches it against the built `dist/`.
 - **Calling convention (since 0.9.0, issue #41):** the 15 algorithm modules (`imgproc`, `math`, `matmath`, `linalg`, `transform`, `fast_corners`, `yape`, `yape06`, `orb`, `optical_flow_lk`, `motion_estimator`, `affine2d`, `homography2d`, `bfmatcher`, `gms`, plus the `cache` pool) are **singleton instances** on the namespace — `jsfeatNext.imgproc.grayscale(...)`, no `new` — matching original jsfeat. The data-structure classes (`matrix_t`, `keypoint_t`, `pyramid_t`, `ransac_params_t`, `match_t`, `pose_t`) remain constructors, and so does `pose_estimator`.
   - **`pose_estimator` is deliberately NOT a singleton and deliberately does not extend `core`.** It is *stateful* — it holds the inverted intrinsics `K⁻¹` — and the public API constructs it with a `K` (`new jsfeatNext.pose_estimator(K)`), which also makes its `intrinsics()` factory reachable as a `static` on the namespace class. It therefore belongs with the constructors above, not with the stateless algorithm singletons. Review tooling has flagged this twice as a rule violation; it is not one, and the reasoning is repeated in the class's own JSDoc.
 - **One shared buffer pool:** all modules borrow scratch buffers from the single `shared_cache` exported by `src/core/core.ts` (public as `jsfeatNext.cache`), exactly like jsfeat's global `jsfeat.cache`. Balance every `get_buffer` with a `put_buffer`.
 
@@ -26,6 +26,21 @@ const src = new jsfeatNext.matrix_t(width, height, jsfeatNext.U8_t | jsfeatNext.
 jsfeatNext.imgproc.grayscale(rgbaPixelData, width, height, src);
 ```
 
+With a bundler, import only what you use by name, and the rest of the library is
+left out of your bundle (since 1.2.0, #137). Each name is the same object as the
+namespace member, so `imgproc === jsfeatNext.imgproc`:
+
+```js
+import { imgproc, matrix_t, U8C1_t } from "@webarkit/jsfeat-next";
+
+const src = new matrix_t(width, height, U8C1_t);
+imgproc.grayscale(rgbaPixelData, width, height, src);
+```
+
+An app that only converts to grayscale bundles to about 23 KB this way (8 KB
+gzipped) instead of about 70 KB (24 KB) through the default import, which carries
+every module. Measured with Vite 8, minified; see #137 for the method.
+
 In the browser (UMD build), the global is the namespace directly:
 
 ```html
@@ -59,9 +74,9 @@ These classes are attached to the `jsfeatNext` namespace (`jsfeatNext.<name>`):
 
 - **Node.js** v24 (see `.nvmrc`; npm 11)
 - Build (UMD + ESM + type declarations): `npm install` then `npm run build-ts`
-  - Produces `dist/jsfeatNext.js` (UMD, browser global `jsfeatNext`), `dist/jsfeatNext.mjs` (ESM), and `types/`
-  - Built with **Vite** library mode; webpack/babel are no longer used
-- Watch mode: `npm run dev-ts`
+  - Produces `dist/jsfeatNext.js` (UMD, browser global `jsfeatNext`), `dist/jsfeatNext.mjs` (ESM, default namespace plus named exports), and `types/`
+  - Built with **Vite** library mode, in two passes: ESM from `src/index.ts`, UMD from `src/umd.ts` (namespace only); webpack/babel are no longer used
+- Watch mode: `npm run dev-ts` (ESM and types) · `npm run dev-ts:umd` (UMD)
 - Tests: `npm test` (Vitest — characterization tests against the original jsfeat)
 - API docs: `npm run docs` (TypeDoc, output to `docs/api/`, gitignored/local-only for now)
 - Benchmarks: `npm run bench` (Vitest, A/B against the vendored original jsfeat) · `npm run bench:ratios` for the ratio summary alone
 
@@ -5,6 +5,7 @@
   "main": "dist/jsfeatNext.js",
   "module": "dist/jsfeatNext.mjs",
   "types": "types/src/index.d.ts",
+  "sideEffects": false,
   "unpkg": "dist/jsfeatNext.js",
   "jsdelivr": "dist/jsfeatNext.js",
   "exports": {
@@ -22,8 +23,9 @@
   ],
   "scripts": {
     "prepare": "npm run build-ts",
-    "build-ts": "vite build",
+    "build-ts": "vite build && vite build --mode umd",
     "dev-ts": "vite build --watch",
+    "dev-ts:umd": "vite build --mode umd --watch",
     "format-check": "prettier --check .",
     "format": "prettier --write .",
     "license-check": "node scripts/check-license-headers.mjs",
 
@@ -45,6 +45,9 @@ const EXTENDED = new Map([
 const ORIGINAL_SRC = new Set([
     "src/types.ts",
     "src/index.ts",
+    // build wiring for the named exports and the UMD entry (#137): no ported code
+    "src/singletons.ts",
+    "src/umd.ts",
     // match_t is an OpenCV-shaped value type (cv::DMatch equivalent); jsfeat
     // never shipped a matcher or any such type, so nothing here is derived.
     // (bfmatcher.ts itself IS derived — it ports the sample's popcnt32/
 
@@ -37,6 +37,7 @@
  */
 
 import jsfeatNext from "./jsfeatNext";
+import core from "./core/core";
 
 /**
  * Package entry point. Since 0.9.0 the default export IS the `jsfeatNext`
@@ -52,28 +53,103 @@ import jsfeatNext from "./jsfeatNext";
  */
 export default jsfeatNext;
 
+/**
+ * Named exports (issue #137), beside the default namespace, never instead of
+ * it: every member of the namespace is also exported under the same name, and
+ * is the very same object (`imgproc === jsfeatNext.imgproc`), so singleton
+ * state such as `fast_corners`' threshold is shared between the two.
+ *
+ * They exist for bundle size. The namespace holds every module, so importing
+ * it ships the whole library; importing by name lets a bundler drop the
+ * modules (and tables, like ORB's) that the code never reads. The ESM build
+ * carries them; the UMD build (`dist/jsfeatNext.js`, built from `src/umd.ts`)
+ * still exposes only the namespace, as CDN `<script>` consumers expect.
+ *
+ * @example
+ * ```ts
+ * import { imgproc, matrix_t, U8C1_t } from "@webarkit/jsfeat-next";
+ * const gray = new matrix_t(w, h, U8C1_t);
+ * imgproc.grayscale(rgba, w, h, gray);
+ * ```
+ */
+export {
+    transform,
+    fast_corners,
+    imgproc,
+    math,
+    matmath,
+    linalg,
+    orb,
+    yape,
+    yape06,
+    motion_estimator,
+    affine2d,
+    homography2d,
+    optical_flow_lk,
+    bfmatcher,
+    gms,
+} from "./singletons";
+export { shared_cache as cache } from "./core/core";
+export { matrix_t } from "./matrix_t/matrix_t";
+export { keypoint_t } from "./keypoint_t/keypoint_t";
+export { pyramid_t } from "./pyramid_t/pyramid_t";
+export { ransac_params_t } from "./motion_estimator/ransac_params_t";
+export { match_t } from "./bfmatcher/match_t";
+export { data_t } from "./node_utils/data_t";
+export { pose_estimator, pose_t } from "./pose_estimator/pose_estimator";
+
+// The namespace's constants, by the same names: the data types and channels a
+// `matrix_t` is built with, the colour codes, the flags and the version. Read
+// from the base class that defines them, so they cannot drift from
+// `jsfeatNext.<name>`.
+export const {
+    VERSION,
+    EPSILON,
+    FLT_MIN,
+    U8_t,
+    S32_t,
+    F32_t,
+    S64_t,
+    F64_t,
+    C1_t,
+    C2_t,
+    C3_t,
+    C4_t,
+    COLOR_RGBA2GRAY,
+    COLOR_RGB2GRAY,
+    COLOR_BGRA2GRAY,
+    COLOR_BGR2GRAY,
+    BOX_BLUR_NOSCALE,
+    SVD_U_T,
+    SVD_V_T,
+    NORM_HAMMING,
+    U8C1_t,
+    U8C3_t,
+    U8C4_t,
+    F32C1_t,
+    F32C2_t,
+    S32C1_t,
+    S32C2_t,
+} = core;
+
 /**
  * Public interfaces and shared types, re-exported from the package root so
  * consumers can type-annotate without deep paths into `types/src/**` (issue
- * #92). These are **type-only** re-exports: they are erased at build time and
- * do not change the UMD/ESM JavaScript bundles (whose `exports: "default"`
- * config exposes only the `jsfeatNext` namespace). The runtime values remain
- * reachable via that namespace — e.g. `new jsfeatNext.matrix_t(...)`.
+ * #92). Type-only: erased at build time. (The classes among them, `matrix_t`,
+ * `keypoint_t` and so on, are exported as values above, which carries their
+ * types too.)
  *
  * @example
  * ```ts
  * import jsfeatNext, { IMatrix_T, TypedArray } from "@webarkit/jsfeat-next";
  * function process(img: IMatrix_T) { ... }
  * ```
  */
-export type { matrix_t, IMatrix_T } from "./matrix_t/matrix_t";
-export type { keypoint_t } from "./keypoint_t/keypoint_t";
-export type { pyramid_t } from "./pyramid_t/pyramid_t";
+export type { IMatrix_T } from "./matrix_t/matrix_t";
 export type { point_t, IPoint_t } from "./point_t/point_t";
-export type { ransac_params_t } from "./motion_estimator/ransac_params_t";
-export type { match_t, IMatch_T } from "./bfmatcher/match_t";
+export type { IMatch_T } from "./bfmatcher/match_t";
 export type { IGmsSize } from "./gms/gms";
-export type { data_t, IData_T } from "./node_utils/data_t";
-export type { pose_t, IPose_T } from "./pose_estimator/pose_estimator";
+export type { IData_T } from "./node_utils/data_t";
+export type { IPose_T } from "./pose_estimator/pose_estimator";
 export type { ICache } from "./cache/cache";
 export type { TypedArray, NumericArray, MotionKernel, RandomFn } from "./types";
@@ -40,28 +40,15 @@
  *
  */
 
-import jsfeatNext, { shared_cache } from "./core/core";
-import { imgproc } from "./imgproc/imgproc";
-import { linalg } from "./linalg/linalg";
-import { fast_corners } from "./fast_corners/fast_corners";
-import { math } from "./math/math";
-import matmath from "./matmath/matmath";
+import core, { shared_cache } from "./core/core";
 import { matrix_t } from "./matrix_t/matrix_t";
 import { pyramid_t } from "./pyramid_t/pyramid_t";
-import { transform } from "./transform/transform";
 import { keypoint_t } from "./keypoint_t/keypoint_t";
-import { orb } from "./orb/orb";
-import { yape } from "./yape/yape";
-import { yape06 } from "./yape06/yape06";
 import { ransac_params_t } from "./motion_estimator/ransac_params_t";
-import { motion_estimator } from "./motion_estimator/motion_estimator";
-import { affine2d, homography2d } from "./motion_model/motion_model";
-import { optical_flow_lk } from "./optical_flow_lk/optical_flow_lk";
-import { bfmatcher } from "./bfmatcher/bfmatcher";
 import { match_t } from "./bfmatcher/match_t";
-import { gms } from "./gms/gms";
 import { data_t } from "./node_utils/data_t";
 import { pose_estimator, pose_t } from "./pose_estimator/pose_estimator";
+import * as singletons from "./singletons";
 
 // Thin aggregator (issue #47): every algorithm lives in its own module under
 // src/<module>/, extending the base class from src/core/core.ts.
@@ -76,59 +63,57 @@ import { pose_estimator, pose_t } from "./pose_estimator/pose_estimator";
 // exactly like jsfeat's global `jsfeat.cache` — see docs/migration-0.9.md.
 // The data-structure classes (matrix_t, keypoint_t, pyramid_t,
 // ransac_params_t) remain constructors: `new jsfeatNext.matrix_t(...)`.
-export default jsfeatNext;
-
-// the shared buffer pool itself, like original jsfeat's `jsfeat.cache`
-jsfeatNext.cache = shared_cache;
-
-// data-structure constructors (unchanged: consumers `new` these)
-jsfeatNext.pyramid_t = pyramid_t;
-
-jsfeatNext.matrix_t = matrix_t;
-
-jsfeatNext.keypoint_t = keypoint_t;
-
-jsfeatNext.ransac_params_t = ransac_params_t;
-
-jsfeatNext.match_t = match_t;
-
-// raw byte storage, like jsfeat's `jsfeat.data_t` (surface parity, #45)
-jsfeatNext.data_t = data_t;
-
-// pose_estimator is stateful (holds inverted intrinsics), constructed with a
-// K, so it is a constructor class like matrix_t -- NOT a stateless singleton.
-// pose_t is its output data-struct.
-jsfeatNext.pose_estimator = pose_estimator;
-
-jsfeatNext.pose_t = pose_t;
-
-// algorithm singletons (no `new` — call methods directly)
-jsfeatNext.transform = new transform();
-
-jsfeatNext.fast_corners = new fast_corners();
-
-jsfeatNext.imgproc = new imgproc();
-
-jsfeatNext.math = new math();
-
-jsfeatNext.matmath = new matmath();
-
-jsfeatNext.linalg = new linalg();
-
-jsfeatNext.orb = new orb();
-
-jsfeatNext.yape = new yape();
-
-jsfeatNext.yape06 = new yape06();
-
-jsfeatNext.motion_estimator = new motion_estimator();
-
-jsfeatNext.affine2d = new affine2d();
-
-jsfeatNext.homography2d = new homography2d();
-
-jsfeatNext.optical_flow_lk = new optical_flow_lk();
-
-jsfeatNext.bfmatcher = new bfmatcher();
-
-jsfeatNext.gms = new gms();
+//
+// How the namespace is built matters for bundle size (#137). It is a SUBCLASS
+// of the base class every module extends, not that base class itself: it
+// inherits the base's statics (the data-type and colour constants, VERSION),
+// and the members attached here land on it alone. And it is built in ONE
+// expression marked @__PURE__, rather than by assigning members one statement
+// at a time: a bundler must keep every `ns.orb = orb` statement, because
+// writing a property of a class may run a setter, and each one would keep its
+// module alive. As a single pure expression, a bundle whose code never reads
+// the namespace (one that only uses `import { imgproc }`) drops it whole, and
+// every module the code does not use goes with it. (The subclass is declared
+// on its own line, not inline: TypeScript cannot emit a declaration for an
+// exported anonymous class whose base has protected members, TS4094.)
+class jsfeatNext extends core {}
+
+const namespace = /* @__PURE__ */ Object.assign(jsfeatNext, {
+    // the shared buffer pool itself, like original jsfeat's `jsfeat.cache`
+    cache: shared_cache,
+
+    // data-structure constructors (unchanged: consumers `new` these)
+    pyramid_t,
+    matrix_t,
+    keypoint_t,
+    ransac_params_t,
+    match_t,
+    // raw byte storage, like jsfeat's `jsfeat.data_t` (surface parity, #45)
+    data_t,
+    // pose_estimator is stateful (holds inverted intrinsics), constructed with
+    // a K, so it is a constructor class like matrix_t -- NOT a stateless
+    // singleton. pose_t is its output data-struct.
+    pose_estimator,
+    pose_t,
+
+    // algorithm singletons (no `new` — call methods directly). Created once in
+    // ./singletons, which src/index.ts also re-exports by name (#137), so
+    // `jsfeatNext.imgproc` and `import { imgproc }` are the same object.
+    transform: singletons.transform,
+    fast_corners: singletons.fast_corners,
+    imgproc: singletons.imgproc,
+    math: singletons.math,
+    matmath: singletons.matmath,
+    linalg: singletons.linalg,
+    orb: singletons.orb,
+    yape: singletons.yape,
+    yape06: singletons.yape06,
+    motion_estimator: singletons.motion_estimator,
+    affine2d: singletons.affine2d,
+    homography2d: singletons.homography2d,
+    optical_flow_lk: singletons.optical_flow_lk,
+    bfmatcher: singletons.bfmatcher,
+    gms: singletons.gms,
+});
+
+export default namespace;
@@ -51,8 +51,10 @@ import { linalg, LMCallback } from "../linalg/linalg";
 // One instance each, shared by every call (#169): constructing them per call
 // was a measurable fixed cost on the 3- and 4-point RANSAC minimal samples,
 // where the real arithmetic is smallest. Both classes are stateless.
-const shared_matmath = new matmath();
-const shared_linalg = new linalg();
+// @__PURE__ (#137): construction has no effect beyond the instance, so a
+// bundle that never uses motion_model drops both, and linalg with them.
+const shared_matmath = /* @__PURE__ */ new matmath();
+const shared_linalg = /* @__PURE__ */ new linalg();
 
 /**
  * Shared base of the motion-model kernels ({@link affine2d},
 
@@ -55,8 +55,9 @@ import { rectify_patch } from "./rectify_patch";
  * Module scope, not an instance field: it is a read-only constant shared by
  * every call, and hoisting it out of the method keeps the hot loop free of a
  * per-call allocation (the same reason `bit_pattern_31` lives in its own file).
+ * `@__PURE__` lets a bundle that never uses ORB drop it (#137).
  */
-const u_max = new Int32Array([15, 15, 15, 15, 14, 14, 14, 13, 13, 12, 11, 10, 9, 8, 6, 3, 0]);
+const u_max = /* @__PURE__ */ new Int32Array([15, 15, 15, 15, 14, 14, 14, 13, 13, 12, 11, 10, 9, 8, 6, 3, 0]);
 
 /**
  * ORB binary descriptor extractor (Oriented FAST and Rotated BRIEF): for