@flyfish-dev/dwf-viewer 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,12 +1,27 @@
 # Changelog
 
+## 0.6.0
+
+- Added WebGL-accelerated XPS/DWFx 2D vector rendering through `WebGlXpsBackend`.
+- Added XPS ODTTF embedded font deobfuscation/loading for CAD-like text appearance.
+- Tuned demo defaults for dense CAD overview linework and lower DPR memory pressure.
+- Added curated Autodesk floor-plan DWFx demo entry with default A03 sheet.
+- Coalesced viewer render requests to avoid zoom/pan render pile-ups.
+- Kept Cloudflare demo assets versioned under `dist-v0.6.0` to prevent stale browser module caches.
+
+## 0.5.1
+
+- Added CAD adaptive line-weight rendering for XPS FixedPage, W2D Canvas/WASM, and W2D WebGL paths.
+- Added overview text LOD culling to avoid dense annotation blobs at fit-to-page while preserving text when zoomed in.
+- Added embedded XPS TrueType font loading for Glyphs when browsers support the FontFace API.
+- Added demo line-weight mode selector: CAD adaptive, hairline, physical.
+- Versioned demo dist assets under `dist-v0.5.1` to prevent stale browser module caches.
+
 ## 0.5.0
 
-- Prepared repository for public npm release and Cloudflare Pages demo deployment.
-- Renamed the public package metadata to `dwf-viewer`.
-- Added dual npm publishing support for `dwf-viewer` and `@flyfish-dev/dwf-viewer`.
-- Switched the project license to `AGPL-3.0-only` and added `NOTICE`.
-- Normalized GitHub repository metadata for `flyfish-dev/dwf-viewer`.
+- Prepared the repository for public npm release and Cloudflare Pages demo deployment.
+- Published normalized packages as `dwf-viewer` and `@flyfish-dev/dwf-viewer`.
+- Adopted `AGPL-3.0-only` with `NOTICE` for strict open-source distribution.
 - Added curated, de-duplicated demo example manifest.
 - Removed production-success info diagnostics from W3D/eModel pages so the Robot Arm demo renders with zero page diagnostics.
-- Added static demo build pipeline and package validation scripts.
+- Added static demo build pipeline, package validation scripts, CI, and publish helpers.

package/PRODUCTION_3D_NOTES.md

@@ -46,3 +46,7 @@ Serve the WASM file with `application/wasm`. The Cloudflare Pages demo writes `_
 ## Unsupported semantics
 
 Unsupported historical HSF opcodes, advanced CAD display-list behavior, and full Design Review parity are tracked as incremental parser work. The rendering contract is: exact-enough supported semantics are displayed, unsupported semantics are diagnosed, and known-failing 3D geometry is not hidden by image fallback.
+
+## 2D production rendering update
+
+Version 0.6.0 adds WebGL acceleration for XPS/DWFx vector geometry and keeps text/images in a Canvas overlay. This avoids CPU redraw bottlenecks when zooming dense sheets and keeps GPU memory bounded through scene cache limits. Embedded ODTTF fonts are deobfuscated and loaded through FontFace where supported, producing CAD-like text weights in the demo.

package/README.md

@@ -1,21 +1,36 @@
 # DWF Viewer
 
-Pure frontend DWF/DWFx viewer for browsers. It parses DWF/DWFx packages locally in the browser and renders common 2D and 3D content without a server-side CAD conversion service.
+Pure frontend DWF/DWFx CAD viewer for browsers. It parses DWF/DWFx packages locally and renders common 2D and 3D content without a server-side CAD conversion service.
 
-## Status
+## Links
 
-This repository is structured as a publishable npm package plus a static Cloudflare Pages demo. The same build is published under both `dwf-viewer` and `@flyfish-dev/dwf-viewer`.
+| Entry | URL |
+|---|---|
+| Online demo | https://dwf-viewer-demo.pages.dev/ |
+| Repository | https://github.com/flyfish-dev/dwf-viewer |
+| npm | https://www.npmjs.com/package/dwf-viewer |
+| scoped npm | https://www.npmjs.com/package/@flyfish-dev/dwf-viewer |
+
+Current version: `0.6.0`
+
+## Why
+
+DWF and DWFx are still common in manufacturing, construction, field service, engineering archives, PLM, after-sales systems, and document management products. Many web systems can preview PDF, Office files, and images, but DWF often falls back to desktop viewers, server-side conversion, or static thumbnails.
+
+DWF Viewer is built for the browser-native path: parse the package, decode the sheet/model data, and render it directly inside a web application. This keeps integration simple for private deployments and reduces conversion queues, temporary files, and infrastructure coupling.
 
-Supported paths:
+## Supported Paths
 
 | Format / content | Status |
 |---|---|
 | DWF 6+ ZIP container | Supported |
 | DWFx / OPC package | Supported |
-| XPS FixedPage 2D sheets | Supported common subset |
+| XPS FixedPage 2D sheets | Supported common subset with WebGL vector acceleration and Canvas text/image overlay |
 | Classic binary WHIP!/W2D 2D sheets | Supported for core geometry/text/images used by Autodesk samples |
+| Textual W2D pages | Supported for smoke tests and simple sheets |
 | W3D/HSF 3D eModel shell geometry | Supported: uncompressed, CS_TRIVIAL, and Edgebreaker shell meshes |
 | Three.js adapter | Supported |
+| Built-in WebGL 3D renderer | Supported through `DwfViewer` |
 | WASM raster fallback | Supported for 2D vector rasterization |
 | eModel metadata | Materials, textures, scene tree, saved views, PMI/animation data containers |
 
@@ -31,7 +46,7 @@ npm install @flyfish-dev/dwf-viewer three
 
 `three` is an optional peer dependency. It is required only when you use `createThreeGroupFromW3d()` directly. The built-in `DwfViewer` uses its own WebGL 3D renderer.
 
-## Basic browser usage
+## Basic Browser Usage
 
 ```ts
 import 'dwf-viewer/styles.css';
@@ -41,10 +56,15 @@ const viewer = new DwfViewer(document.getElementById('viewer')!, {
   wasmUrl: '/dwfv-render.wasm',
   preferWebgl: true,
   preferWasm: true,
-  maxDevicePixelRatio: 2,
-  maxCanvasPixels: 16_777_216,
-  maxGpuCacheBytes: 160 * 1024 * 1024,
-  maxCachedScenes: 2
+  maxDevicePixelRatio: 1.5,
+  maxCanvasPixels: 12_000_000,
+  maxGpuCacheBytes: 192 * 1024 * 1024,
+  maxCachedScenes: 4,
+  lineWeightMode: 'adaptive',
+  minStrokeCssPx: 0.42,
+  maxOverviewStrokeCssPx: 0.9,
+  minTextCssPx: 1.05,
+  minFilledAreaCssPx: 0.04
 });
 
 await viewer.load(file);
@@ -56,7 +76,47 @@ Copy the WASM asset from the package into your public assets directory:
 cp node_modules/dwf-viewer/public/dwfv-render.wasm public/dwfv-render.wasm
 ```
 
-## Three.js integration
+For the scoped package:
+
+```bash
+cp node_modules/@flyfish-dev/dwf-viewer/public/dwfv-render.wasm public/dwfv-render.wasm
+```
+
+## WebGL 2D Rendering
+
+Version `0.6.0` adds WebGL-accelerated XPS/DWFx 2D vector rendering through `WebGlXpsBackend`, alongside the existing W2D WebGL path.
+
+The built-in viewer uses WebGL for Classic W2D and DWFx/XPS vector geometry when `preferWebgl` is enabled. Geometry is uploaded to GPU buffers and cached by page and zoom bucket; pan operations update shader uniforms. Text, images, and XPS image brushes stay on the transparent Canvas overlay so browser font rendering and bitmap decoding remain reliable.
+
+For dense architectural sheets, the demo defaults are tuned for CAD review: 1.5 maximum DPR, a 12M-pixel canvas cap, adaptive thin-line overview, and render coalescing during wheel/pointer interaction.
+
+## CAD Line-Weight Rendering
+
+The default 2D rendering mode is `lineWeightMode: 'adaptive'`. At fit-to-page, linework is normalized toward screen-space hairlines so dense drawings remain readable; as zoom increases, original DWF/XPS line weights return progressively.
+
+Available modes:
+
+| Mode | Behavior |
+|---|---|
+| `adaptive` | Default. Overview thin-line rendering with zoom-aware recovery of source line weights. |
+| `hairline` | Force strokes to a visible CSS-pixel hairline. Useful for dense plans and review thumbnails. |
+| `physical` | Preserve source stroke widths. Useful for print-fidelity comparisons; dense sheets can look heavy when zoomed out. |
+
+Related options:
+
+```ts
+new DwfViewer(el, {
+  lineWeightMode: 'adaptive',
+  minStrokeCssPx: 0.42,
+  maxOverviewStrokeCssPx: 0.9,
+  minTextCssPx: 1.05,
+  minFilledAreaCssPx: 0.04
+});
+```
+
+XPS/DWFx `Glyphs` use embedded TrueType fonts when the browser allows `FontFace` loading. Very small text is skipped in adaptive overview mode and appears normally when zoomed in; this avoids unreadable annotation blocks in dense architectural sheets.
+
+## Three.js Integration
 
 ```ts
 import * as THREE from 'three';
@@ -69,7 +129,6 @@ if (page?.kind === 'w3d-model') {
   const group = createThreeGroupFromW3d(page, THREE, {
     showFeatureEdges: true,
     textureResolver(texture) {
-      // Return a THREE.Texture if your app wants to bind DWFx texture resources.
       return undefined;
     }
   });
@@ -77,7 +136,7 @@ if (page?.kind === 'w3d-model') {
 }
 ```
 
-## Local development
+## Local Development
 
 ```bash
 npm install
@@ -92,14 +151,15 @@ Then open:
 http://127.0.0.1:8080/
 ```
 
-## Example set
+## Example Set
 
 The demo examples are listed in `examples/manifest.json` and are intentionally de-duplicated:
 
 | Example | Purpose |
 |---|---|
-| `robot-arm.dwfx` | 3D W3D/HSF eModel with shell meshes, scene tree, materials, textures, saved views |
-| `blocks-and-tables.dwf` | Binary WHIP!/W2D 2D ePlot sample |
+| `autodesk-floor-plans.dwfx` | Multi-page architectural DWFx/XPS sample, defaulting to A03 First Floor Plan for WebGL XPS, embedded font, and thin-line overview validation |
+| `robot-arm.dwfx` | 3D W3D/HSF eModel with shell meshes, scene tree, materials, textures, and saved views |
+| `blocks-and-tables.dwf` | Binary WHIP!/W2D ePlot sample |
 | `minimal-xps.dwfx` | Small DWFx/XPS FixedPage sample |
 | `text-w2d.dwf` | Textual W2D smoke-test sample |
 
@@ -109,27 +169,24 @@ Run:
 npm run check:examples
 ```
 
-## NPM publishing checklist
+## NPM Publishing Checklist
 
 ```bash
 npm run clean
+npm run build
+npm run validate:production
+npm run check:package
 npm run publish:all
 ```
 
-`publish:all` builds once, validates the production examples, checks the package tarball, then publishes both `dwf-viewer` and `@flyfish-dev/dwf-viewer`. Add npm options when needed:
+The package is published as both `dwf-viewer` and `@flyfish-dev/dwf-viewer`.
 
-```bash
-npm run publish:all -- --dry-run
-npm run publish:all -- --otp=123456
-```
-
-GitHub release publishing can use provenance through the included workflow and `NPM_TOKEN`.
-
-## Cloudflare Pages demo
+## Cloudflare Pages Demo
 
 The repository includes `wrangler.toml` with:
 
 ```toml
+name = "dwf-viewer-demo"
 pages_build_output_dir = "./demo-dist"
 ```
 
@@ -144,11 +201,10 @@ Root directory: /
 Direct upload:
 
 ```bash
-npm run build:demo
-npx wrangler pages deploy demo-dist
+npm run deploy:pages
 ```
 
-`build:demo` produces a static directory containing only demo HTML/JS, `dist`, `public/dwfv-render.wasm`, `styles`, and the curated examples.
+`build:demo` produces a static directory containing demo HTML/JS, a versioned `dist-v*` directory, `public/dwfv-render.wasm`, `styles`, and curated examples. Versioned dist assets prevent stale browser module caches after releases.
 
 ## Public API
 
@@ -159,6 +215,7 @@ openDwfDocument(input, options?)
 DwfViewer
 PageRenderer
 WebGlW2dBackend
+WebGlXpsBackend
 ThreeW3dRenderer
 createThreeGroupFromW3d(page, THREE, options?)
 ```
@@ -168,6 +225,7 @@ Types:
 ```ts
 LoadedDwfDocument
 PageData
+XpsPageData
 W3dPageData
 W3dModelData
 W3dMeshData
@@ -176,15 +234,20 @@ Diagnostic
 RenderStats
 ```
 
-## Production behavior
+## Production Behavior
 
-The production validation target is strict for the bundled Robot Arm eModel:
+The production validation target is strict for the bundled samples:
 
 ```text
+Robot Arm:
 page kind: w3d-model
 meshes >= 30
 triangles >= 40,000
-page diagnostics: 0
+non-info diagnostics: 0
+
+Autodesk Floor Plans:
+page kind: xps-fixed-page
+pages >= 18
 non-info diagnostics: 0
 ```
 
@@ -194,10 +257,12 @@ Run:
 npm run validate:production
 ```
 
-## Known boundaries
+## License
+
+DWF Viewer is licensed under `AGPL-3.0-only`. See `LICENSE` and `NOTICE`.
 
-This is a pure frontend implementation, not Autodesk Design Review or HOOPS Exchange. The parser is intentionally fail-closed for unsupported historical HSF/W2D opcode semantics: it should show explicit diagnostics instead of silently drawing incorrect geometry. Current production coverage includes the core 2D/3D rendering paths needed by the bundled samples and the extension points for materials, textures, PMI, animation and selection tree metadata.
+Commercial use, private forks, and second-development integrations must comply with the license and preserve attribution. Contributions are welcome through Issues and Pull Requests.
 
-## License
+## Known Boundaries
 
-AGPL-3.0-only. See `LICENSE` and `NOTICE`.
+This is a pure frontend implementation and is not affiliated with Autodesk Design Review or HOOPS Exchange. The parser is intentionally fail-closed for unsupported historical HSF/W2D opcode semantics: it should show explicit diagnostics instead of silently drawing guessed geometry. Current production coverage includes the core 2D/3D rendering paths needed by the bundled samples and extension points for materials, textures, PMI, animation, and selection tree metadata.

package/dist/format/types.d.ts

@@ -45,6 +45,11 @@ export interface InflateProvider {
 }
 export interface PageRenderOptions {
     pageIndex?: number;
+    lineWeightMode?: 'adaptive' | 'physical' | 'hairline';
+    minStrokeCssPx?: number;
+    maxOverviewStrokeCssPx?: number;
+    minTextCssPx?: number;
+    minFilledAreaCssPx?: number;
     preferWebgl?: boolean;
     preferWasm?: boolean;
     wasmUrl?: string;
@@ -53,7 +58,7 @@ export interface PageRenderOptions {
     maxCachedScenes?: number;
 }
 export interface RenderStats {
-    backend: 'canvas2d' | 'wasm-raster' | 'webgl' | 'threejs-webgl' | 'image' | 'unsupported';
+    backend: 'canvas2d' | 'wasm-raster' | 'webgl' | 'webgl-xps' | 'threejs-webgl' | 'image' | 'unsupported';
     commands: number;
     warnings: Diagnostic[];
 }

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export type { DwfViewerOptions, LoadOptions } from './viewer/DwfViewer.js';
 export { PageRenderer } from './render/PageRenderer.js';
 export { WasmRasterBackend } from './wasm/WasmRasterBackend.js';
 export { WebGlW2dBackend } from './render/WebGlW2dBackend.js';
+export { WebGlXpsBackend } from './render/WebGlXpsBackend.js';
 export { ThreeW3dRenderer } from './render/ThreeW3dRenderer.js';
 export { createThreeGroupFromW3d } from './render/ThreeJsSceneAdapter.js';
 export type { LoadedDwfDocument, PageData, XpsPageData, W2dTextPageData, ImagePageData, UnsupportedPageData, W3dPageData, W3dModelData, W3dMeshData, W2dPrimitive } from './format/document.js';

package/dist/index.js

@@ -5,5 +5,6 @@ export { DwfViewer } from './viewer/DwfViewer.js';
 export { PageRenderer } from './render/PageRenderer.js';
 export { WasmRasterBackend } from './wasm/WasmRasterBackend.js';
 export { WebGlW2dBackend } from './render/WebGlW2dBackend.js';
+export { WebGlXpsBackend } from './render/WebGlXpsBackend.js';
 export { ThreeW3dRenderer } from './render/ThreeW3dRenderer.js';
 export { createThreeGroupFromW3d } from './render/ThreeJsSceneAdapter.js';

package/dist/render/PageRenderer.d.ts

@@ -2,6 +2,11 @@ import { type RenderStats } from '../format/types.js';
 import type { LoadedDwfDocument } from '../format/document.js';
 export interface GenericRenderOptions {
     zoom?: number;
+    lineWeightMode?: 'adaptive' | 'physical' | 'hairline';
+    minStrokeCssPx?: number;
+    maxOverviewStrokeCssPx?: number;
+    minTextCssPx?: number;
+    minFilledAreaCssPx?: number;
     panX?: number;
     panY?: number;
     preferWebgl?: boolean;

package/dist/render/PageRenderer.js

@@ -30,6 +30,7 @@ export class PageRenderer {
         return this.renderUnsupported(page, canvas, options);
     }
     dispose() {
+        this.xps?.dispose();
         this.w2d?.dispose();
         this.w3d?.dispose();
     }

package/dist/render/W2dRenderer.d.ts

@@ -1,6 +1,7 @@
 import { type RenderStats } from '../format/types.js';
 import type { W2dTextPageData } from '../format/document.js';
-export interface W2dRenderOptions {
+import { type CadLineStyleOptions } from './cadLineStyle.js';
+export interface W2dRenderOptions extends CadLineStyleOptions {
     zoom?: number;
     panX?: number;
     panY?: number;

package/dist/render/W2dRenderer.js

@@ -1,6 +1,7 @@
 import { actionableDiagnostics, diag } from '../format/types.js';
 import { applyPathToCanvas, flattenPath } from './xpsPath.js';
 import { multiplyMatrix, parseBrushColor, transformPoint } from './style.js';
+import { adaptiveStrokeUserWidth, canvasDpr, estimateMatrixScale, shouldDrawTextByPixelSize } from './cadLineStyle.js';
 import { matrixForW2d } from './viewport.js';
 import { WasmRasterBackend } from '../wasm/WasmRasterBackend.js';
 import { WebGlW2dBackend } from './WebGlW2dBackend.js';
@@ -30,6 +31,7 @@ export class W2dRenderer {
         if (!ctx)
             throw new Error('CanvasRenderingContext2D is not available.');
         const pageMatrix = matrixForW2d(page, canvas.width, canvas.height, options.zoom, options.panX, options.panY);
+        const runtime = { dpr: canvasDpr(canvas), zoom: options.zoom ?? 1 };
         let commands = 0;
         if (options.preferWasm) {
             try {
@@ -37,11 +39,11 @@ export class W2dRenderer {
                 await this.wasm.init();
                 this.wasm.begin(canvas.width, canvas.height, bg);
                 for (const p of page.primitives)
-                    commands += this.drawPrimitiveWasm(p, pageMatrix);
+                    commands += this.drawPrimitiveWasm(p, pageMatrix, options, runtime);
                 ctx.setTransform(1, 0, 0, 1, 0, 0);
                 ctx.putImageData(this.wasm.toImageData(), 0, 0);
                 for (const p of page.primitives.filter(p => p.type === 'text'))
-                    commands += this.drawPrimitiveCanvas(ctx, p, pageMatrix);
+                    commands += this.drawPrimitiveCanvas(ctx, p, pageMatrix, options, runtime);
                 return { backend: 'wasm-raster', commands, warnings };
             }
             catch (err) {
@@ -54,7 +56,7 @@ export class W2dRenderer {
         ctx.fillRect(0, 0, canvas.width, canvas.height);
         ctx.restore();
         for (const p of page.primitives)
-            commands += this.drawPrimitiveCanvas(ctx, p, pageMatrix);
+            commands += this.drawPrimitiveCanvas(ctx, p, pageMatrix, options, runtime);
         return { backend: 'canvas2d', commands, warnings };
     }
     dispose() {
@@ -70,14 +72,14 @@ export class W2dRenderer {
         }
         return this.webgl;
     }
-    drawPrimitiveCanvas(ctx, p, pageMatrix) {
+    drawPrimitiveCanvas(ctx, p, pageMatrix, options, runtime) {
         const matrix = multiplyMatrix(pageMatrix, p.matrix ?? { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 });
         const stroke = parseBrushColor(p.stroke ?? '#000000') ?? '#000000';
         const fill = parseBrushColor(p.fill);
         if (p.type === 'text') {
             const [x, y] = transformPoint(matrix, p.x, p.y);
-            const screenSize = Math.max(4, Math.abs((p.size ?? 12) * estimateScale(matrix)));
-            if (screenSize < 2.5 || x > ctx.canvas.width + 64 || y > ctx.canvas.height + 64 || x < -ctx.canvas.width || y < -ctx.canvas.height)
+            const screenSize = Math.max(1, Math.abs((p.size ?? 12) * estimateScale(matrix)));
+            if (!shouldDrawTextByPixelSize(p.size ?? 12, matrix, options, runtime) || x > ctx.canvas.width + 64 || y > ctx.canvas.height + 64 || x < -ctx.canvas.width || y < -ctx.canvas.height)
                 return 0;
             ctx.save();
             ctx.setTransform(1, 0, 0, 1, 0, 0);
@@ -91,7 +93,7 @@ export class W2dRenderer {
         }
         ctx.save();
         ctx.setTransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
-        ctx.lineWidth = Math.max(0.1, (p.lineWidth ?? 1));
+        ctx.lineWidth = adaptiveStrokeUserWidth(p.lineWidth ?? 1, matrix, options, runtime);
         if (p.type === 'polyline') {
             if (p.points.length >= 4) {
                 ctx.beginPath();
@@ -144,25 +146,26 @@ export class W2dRenderer {
         ctx.restore();
         return 1;
     }
-    drawPrimitiveWasm(p, pageMatrix) {
+    drawPrimitiveWasm(p, pageMatrix, options, runtime) {
         if (!this.wasm || p.type === 'text')
             return 0;
         const matrix = multiplyMatrix(pageMatrix, p.matrix ?? { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 });
-        const scale = estimateScale(matrix);
+        const scale = estimateMatrixScale(matrix);
+        const screenStroke = (w) => adaptiveStrokeUserWidth(w ?? 1, matrix, options, runtime) * scale;
         if (p.type === 'polyline') {
-            this.wasm.drawPolyline(p.points, matrix, parseBrushColor(p.stroke ?? '#000000'), (p.lineWidth ?? 1) * scale);
+            this.wasm.drawPolyline(p.points, matrix, parseBrushColor(p.stroke ?? '#000000'), screenStroke(p.lineWidth));
         }
         else if (p.type === 'polygon') {
             this.wasm.drawPolygon(p.points, matrix, parseBrushColor(p.fill));
             if (p.stroke)
-                this.wasm.drawPolyline(closePoints(p.points), matrix, parseBrushColor(p.stroke), (p.lineWidth ?? 1) * scale);
+                this.wasm.drawPolyline(closePoints(p.points), matrix, parseBrushColor(p.stroke), screenStroke(p.lineWidth));
         }
         else if (p.type === 'rect') {
             const pts = [p.x, p.y, p.x + p.width, p.y, p.x + p.width, p.y + p.height, p.x, p.y + p.height, p.x, p.y];
             if (p.fill)
                 this.wasm.drawPolygon(pts, matrix, parseBrushColor(p.fill));
             if (p.stroke)
-                this.wasm.drawPolyline(pts, matrix, parseBrushColor(p.stroke), (p.lineWidth ?? 1) * scale);
+                this.wasm.drawPolyline(pts, matrix, parseBrushColor(p.stroke), screenStroke(p.lineWidth));
         }
         else if (p.type === 'path') {
             const subs = flattenPath(p.commands, 0.5);
@@ -174,7 +177,7 @@ export class W2dRenderer {
                         this.wasm.drawPolygon(s.points, matrix, fill);
             if (stroke)
                 for (const s of subs)
-                    this.wasm.drawPolyline(s.points, matrix, stroke, (p.lineWidth ?? 1) * scale);
+                    this.wasm.drawPolyline(s.points, matrix, stroke, screenStroke(p.lineWidth));
         }
         return 1;
     }

package/dist/render/WebGlW2dBackend.d.ts

@@ -1,6 +1,7 @@
 import type { Diagnostic } from '../format/types.js';
 import type { W2dTextPageData } from '../format/document.js';
-export interface WebGlW2dRenderOptions {
+import { type CadLineStyleOptions } from './cadLineStyle.js';
+export interface WebGlW2dRenderOptions extends CadLineStyleOptions {
     zoom?: number;
     panX?: number;
     panY?: number;

package/dist/render/WebGlW2dBackend.js

@@ -1,6 +1,7 @@
 import { diag } from '../format/types.js';
 import { flattenPath } from './xpsPath.js';
 import { colorToRgba32, multiplyMatrix, transformPoint } from './style.js';
+import { adaptiveStrokeUserWidth, canvasDpr, estimateMatrixScale } from './cadLineStyle.js';
 import { matrixForW2d } from './viewport.js';
 const VERTEX_STRIDE = 12;
 const DEFAULT_MAX_GPU_CACHE_BYTES = 96 * 1024 * 1024;
@@ -38,11 +39,13 @@ export class WebGlW2dBackend {
             return { commands: 0, warnings, gpuBytes: this.gpuBytes, vertexCount: 0, textCount: 0, cacheHit: true };
         }
         this.resize(targetCanvas.width, targetCanvas.height);
-        const key = sceneKey(page);
+        const pageMatrix = matrixForW2d(page, this.canvas.width, this.canvas.height, options.zoom, options.panX, options.panY);
+        const runtime = { dpr: canvasDpr(targetCanvas), zoom: options.zoom ?? 1 };
+        const key = sceneKey(page, pageMatrix, options);
         let scene = this.scenes.get(key);
         const cacheHit = !!scene;
         if (!scene) {
-            scene = this.compileScene(page, key, options);
+            scene = this.compileScene(page, key, options, pageMatrix, runtime);
             this.scenes.set(key, scene);
             this.gpuBytes += scene.gpuBytes;
             this.evictIfNeeded(options);
@@ -59,7 +62,6 @@ export class WebGlW2dBackend {
         gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
         gl.clearColor(bg[0], bg[1], bg[2], bg[3]);
         gl.clear(gl.COLOR_BUFFER_BIT);
-        const pageMatrix = matrixForW2d(page, this.canvas.width, this.canvas.height, options.zoom, options.panX, options.panY);
         gl.useProgram(this.program);
         gl.bindBuffer(gl.ARRAY_BUFFER, scene.buffer);
         gl.enableVertexAttribArray(this.aPos);
@@ -103,7 +105,7 @@ export class WebGlW2dBackend {
             this.canvas.height = height;
         }
     }
-    compileScene(page, key, options) {
+    compileScene(page, key, options, pageMatrix, runtime) {
         const writer = new VertexWriter();
         let primitiveCount = 0;
         let textCount = 0;
@@ -113,7 +115,7 @@ export class WebGlW2dBackend {
                 continue;
             }
             primitiveCount++;
-            appendPrimitive(writer, p);
+            appendPrimitive(writer, p, pageMatrix, options, runtime);
         }
         const bufferBytes = writer.byteLength;
         const maxBytes = options.maxGpuCacheBytes ?? DEFAULT_MAX_GPU_CACHE_BYTES;
@@ -187,8 +189,10 @@ export class WebGlW2dBackend {
     }
 }
 const IDENTITY_MATRIX = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
-function sceneKey(page) {
-    return `${page.id}|${page.sourcePath}|${page.primitives.length}`;
+function sceneKey(page, pageMatrix, options) {
+    const mode = options.lineWeightMode ?? 'adaptive';
+    const scaleBucket = mode === 'physical' ? 'physical' : String(Math.round(Math.log2(Math.max(1e-12, estimateMatrixScale(pageMatrix))) * 8));
+    return `${page.id}|${page.sourcePath}|${page.primitives.length}|lw:${mode}:${scaleBucket}`;
 }
 class VertexWriter {
     constructor() {
@@ -226,10 +230,11 @@ class VertexWriter {
         this.view = new DataView(this.buffer);
     }
 }
-function appendPrimitive(writer, p) {
+function appendPrimitive(writer, p, pageMatrix, options, runtime) {
     const m = p.matrix ?? IDENTITY_MATRIX;
     const matrixScale = estimateScale(m);
-    const lineWidth = Math.max(0.1, (p.lineWidth ?? 1) * matrixScale);
+    const fullMatrix = multiplyMatrix(pageMatrix, m);
+    const lineWidth = Math.max(0.01, adaptiveStrokeUserWidth(p.lineWidth ?? 1, fullMatrix, options, runtime) * matrixScale);
     if (p.type === 'polyline') {
         const color = rgbaBytes(p.stroke ?? '#000000');
         appendPolyline(writer, transformPointsArray(p.points, m), lineWidth, color);

package/dist/render/WebGlXpsBackend.d.ts

@@ -0,0 +1,38 @@
+import type { Diagnostic } from '../format/types.js';
+import type { XpsPageData } from '../format/document.js';
+import { type CadLineStyleOptions } from './cadLineStyle.js';
+export interface WebGlXpsRenderOptions extends CadLineStyleOptions {
+    zoom?: number;
+    panX?: number;
+    panY?: number;
+    background?: string;
+    maxGpuCacheBytes?: number;
+    maxCachedScenes?: number;
+    compositeToTarget?: boolean;
+}
+export interface WebGlXpsRenderResult {
+    commands: number;
+    warnings: Diagnostic[];
+    gpuBytes: number;
+    vertexCount: number;
+    pathCount: number;
+    cacheHit: boolean;
+}
+export declare class WebGlXpsBackend {
+    private readonly canvas;
+    private readonly gl;
+    private readonly program;
+    private readonly aPos;
+    private readonly aColor;
+    private readonly uMatrix;
+    private readonly uViewport;
+    private readonly scenes;
+    private gpuBytes;
+    private tick;
+    constructor(canvas?: HTMLCanvasElement);
+    render(page: XpsPageData, root: Element, targetCanvas: HTMLCanvasElement, options?: WebGlXpsRenderOptions): WebGlXpsRenderResult;
+    dispose(): void;
+    private resize;
+    private compileScene;
+    private evictIfNeeded;
+}