@twinfinity/printing 6.1.1-beta → 6.1.2-ci.30738-beta

package/src/layout/viewportRender.ts

@@ -1,9 +1,10 @@
-import { escapeAttr, getPathValue, resolvePath } from './renderUtils';
-import { rotateBounds, pickScale } from './viewportUtils';
+import { escapeAttr, getPathValue, resolvePath, formatNumber } from './renderUtils';
+import { rotateBounds, pickScale, rotatedContentExtents } from './viewportUtils';
 import { ViewportRenderInfo } from './labelsRender';
-import { matchesV2Filter } from './filters';
-import { ComputedViewportScale, SvgModelView, ViewportElement, AssetSpec } from './types';
+import { matchesFilter } from './filters';
+import { ComputedViewportScale, SvgModelView, ViewportElement, ResourceSpec, ResolvedIncludeFilter } from './types';
 import { isRecord, getProp } from './typeGuards';
+import type { LegendColorAssignment } from './legendRender';
 
 type PolyPoint = { x: number; y: number };
 // Debug overlay for clip polygons. Keep false for normal builds.
@@ -41,7 +42,7 @@ export const renderViewportElement = (
     dataWithViewport: any,
     preferredScales: number[],
     scales: Record<string, { preferredScales?: number[] }>,
-    assetMap: Map<string, AssetSpec>,
+    resourceMap: Map<string, ResourceSpec>,
     viewportScales: Record<string, ComputedViewportScale>,
     viewportClipPolygonsLocal: Record<string, Array<Array<PolyPoint>>>,
     viewportClipBounds: Record<
@@ -51,12 +52,12 @@ export const renderViewportElement = (
     viewportClipLabels: Record<string, boolean>,
     viewportClipStyles: Record<
         string,
-        { stroke?: string; strokeWidthMm?: number; strokeOpacity?: number; fill?: string; fillOpacity?: number }
+        { color?: string; widthMm?: number; opacity?: number; dash?: string; fill?: string; fillOpacity?: number }
     >,
     viewportHighlight: Record<string, { gids: Set<string> | null; styles: any }>,
     viewportRenderInfo: Record<string, ViewportRenderInfo>,
     warnings: string[],
-    legendColorMaps?: Map<string, Map<string, string>>,
+    legendColorMaps?: Map<string, LegendColorAssignment>,
     precomputed?: {
         effectiveWidthModel?: number;
         effectiveHeightModel?: number;
@@ -65,7 +66,8 @@ export const renderViewportElement = (
         clipBounds?: { minX: number; maxX: number; minY: number; maxY: number; width: number; height: number };
         renderCenterModelX?: number;
         renderCenterModelY?: number;
-    }
+    },
+    includeFilters?: ResolvedIncludeFilter[] | null
 ): string[] => {
     const parts: string[] = [];
     if (!baseModel) {
@@ -101,7 +103,19 @@ export const renderViewportElement = (
     const mmPerModel = scaleInfo.mmPerModelUnit;
     const contentWidthMm = renderWidthModel * mmPerModel;
     const contentHeightMm = renderHeightModel * mmPerModel;
-    const rotated = rotateBounds(contentWidthMm, contentHeightMm, rotationDeg);
+    // Tight bounds of the rotated geometry (see rotatedContentExtents): sizes the
+    // content box and re-centers the rotation pivot so diagonally-oriented models
+    // straightened via rotationDeg fill the viewport instead of shrinking to the
+    // inflated AABB-of-AABB. Clip keeps the AABB path — its bounds are the clip
+    // region, not the full geometry.
+    const tight = hasClip ? null : rotatedContentExtents(model, rotationDeg);
+    if (tight && precomputed?.renderCenterModelX == null && precomputed?.renderCenterModelY == null) {
+        renderCenterModelX = tight.centerViewX;
+        renderCenterModelY = tight.centerViewY;
+    }
+    const rotated = tight
+        ? { width: tight.width * mmPerModel, height: tight.height * mmPerModel }
+        : rotateBounds(contentWidthMm, contentHeightMm, rotationDeg);
 
     const centerX = vp.align === 'topLeft' ? vp.xMm + rotated.width / 2 : vp.xMm + vp.widthMm / 2;
     const centerY = vp.align === 'topLeft' ? vp.yMm + rotated.height / 2 : vp.yMm + vp.heightMm / 2;
@@ -113,37 +127,13 @@ export const renderViewportElement = (
     let clipId: string | null = null;
     const clipDebugPolys: string[] = [];
     const clipStyle = viewportClipStyles[vp.id];
-    const clipStroke = clipStyle?.stroke;
-    const clipStrokeWidth = clipStyle?.strokeWidthMm;
-    const clipStrokeOpacity = clipStyle?.strokeOpacity;
+    const clipStroke = clipStyle?.color;
+    const clipStrokeWidth = clipStyle?.widthMm;
+    const clipStrokeOpacity = clipStyle?.opacity;
+    const clipDash = clipStyle?.dash;
     const clipFill = clipStyle?.fill;
     const clipFillOpacity = clipStyle?.fillOpacity;
-    const transformAttr = `translate(${centerX} ${centerY}) rotate(${rotationDeg}) scale(${mmPerModel}) translate(${-renderCenterModelX} ${-renderCenterModelY})`;
-
-    // Debug: log model bounds and path breakdown
-    // if (model.transform) {
-    //   console.log(`[DEBUG MODEL vp="${vp.id}"] Model bounds: viewMinX=${model.transform.viewMinX.toFixed(2)} viewMaxX=${model.transform.viewMaxX?.toFixed(2)} viewMinZ=${model.transform.viewMinZ.toFixed(2)} viewMaxZ=${model.transform.viewMaxZ.toFixed(2)} viewWidth=${model.transform.viewWidth.toFixed(2)} viewHeight=${model.transform.viewHeight.toFixed(2)}`);
-
-    //   if (model.rawPaths) {
-    //     const fills = model.rawPaths.filter(p => p.meta?.isFill);
-    //     const segments = model.rawPaths.filter(p => p.meta?.isSegment);
-    //     const other = model.rawPaths.filter(p => !p.meta?.isFill && !p.meta?.isSegment);
-    //     console.log(`[DEBUG MODEL vp="${vp.id}"] Path breakdown: ${model.rawPaths.length} total (${fills.length} fills, ${segments.length} segments, ${other.length} other)`);
-
-    //     // Sample a few segment paths
-    //     const sampleSegments = segments.slice(0, 3);
-    //     sampleSegments.forEach((seg, idx) => {
-    //       console.log(`[DEBUG MODEL vp="${vp.id}"] Segment ${idx}: class=${seg.meta?.class} fill=${seg.fill} stroke=${seg.stroke} strokeWidth=${seg.strokeWidth} d=${seg.d.substring(0, 50)}...`);
-    //     });
-
-    //     // Check if geometryTransform is present
-    //     if (model.geometryTransform) {
-    //       console.log(`[DEBUG MODEL vp="${vp.id}"] geometryTransform="${model.geometryTransform}"`);
-    //     } else {
-    //       console.log(`[DEBUG MODEL vp="${vp.id}"] WARNING: geometryTransform is MISSING!`);
-    //     }
-    //   }
-    // }
+    const transformAttr = `translate(${formatNumber(centerX)} ${formatNumber(centerY)}) rotate(${rotationDeg}) scale(${mmPerModel}) translate(${formatNumber(-renderCenterModelX)} ${formatNumber(-renderCenterModelY)})`;
 
     // Guard: detect NaN/Infinity in computed transform values
     if (
@@ -159,14 +149,11 @@ export const renderViewportElement = (
         return parts;
     }
 
-    // console.log(`[DEBUG CLIP APPLY vp="${vp.id}"] clipPolysLocal exists: ${!!clipPolysLocal}, length: ${clipPolysLocal?.length ?? 0}`);
     if (clipPolysLocal && clipPolysLocal.length) {
-        // console.log(`[DEBUG CLIP APPLY vp="${vp.id}"] *** APPLYING CLIP-PATH *** with ${clipPolysLocal.length} polygons`);
         if (clipPolysLocal.every((poly) => !poly.length)) {
             warnings.push(`Viewport '${vp.id}' clip has no points after prep; skipping clip.`);
         }
         clipId = `clip-${vp.id}-${parts.length}`;
-        const polyPartsPage: string[] = [];
         // Clip polygon points are in model-view coordinates (not SVG-internal),
         // so transform them with outer only (model-view → page). Do NOT apply
         // geometryTransform — that maps SVG-internal → model-view, which is only
@@ -179,33 +166,21 @@ export const renderViewportElement = (
             )
         );
 
-        // Debug: log clip polygon bounds
-        let clipMinX = Infinity,
-            clipMaxX = -Infinity,
-            clipMinY = Infinity,
-            clipMaxY = -Infinity;
-        clipPolysLocal.forEach((poly) => {
-            poly.forEach((p) => {
-                if (p.x < clipMinX) clipMinX = p.x;
-                if (p.x > clipMaxX) clipMaxX = p.x;
-                if (p.y < clipMinY) clipMinY = p.y;
-                if (p.y > clipMaxY) clipMaxY = p.y;
-            });
-        });
-        // console.log(`[DEBUG CLIP vp="${vp.id}"] Local bounds: x=${clipMinX.toFixed(2)}..${clipMaxX.toFixed(2)} y=${clipMinY.toFixed(2)}..${clipMaxY.toFixed(2)} (w=${(clipMaxX - clipMinX).toFixed(2)} h=${(clipMaxY - clipMinY).toFixed(2)})`);
-
+        // Rings from unioned clips can include holes — a single even-odd path
+        // (rather than one polygon per ring) makes holes subtract correctly in
+        // both the clip mask and any fill.
+        const ringDs: string[] = [];
         clipPolysLocal.forEach((poly) => {
             const pagePtsArr = poly.map((p) => matApply(outer, p));
-            const pagePts = pagePtsArr.map((p) => `${p.x},${p.y}`).join(' ');
-            polyPartsPage.push(`<polygon points="${pagePts}" />`);
-            if (clipStroke || clipFill) {
+            const pagePts = pagePtsArr.map((p) => `${formatNumber(p.x)},${formatNumber(p.y)}`).join(' ');
+            ringDs.push('M ' + pagePtsArr.map((p) => `${formatNumber(p.x)} ${formatNumber(p.y)}`).join(' L ') + ' Z');
+            if (clipStroke) {
                 clipDebugPolys.push(
-                    `<polygon points="${pagePts}"` +
-                        (clipStroke ? ` stroke="${escapeAttr(clipStroke)}"` : '') +
+                    `<polygon points="${pagePts}" fill="none"` +
+                        ` stroke="${escapeAttr(clipStroke)}"` +
                         (clipStrokeWidth ? ` stroke-width="${clipStrokeWidth}"` : '') +
                         (clipStrokeOpacity !== undefined ? ` stroke-opacity="${clipStrokeOpacity}"` : '') +
-                        (clipFill ? ` fill="${escapeAttr(clipFill)}"` : ' fill="none"') +
-                        (clipFillOpacity !== undefined ? ` fill-opacity="${clipFillOpacity}"` : '') +
+                        (clipDash ? ` stroke-dasharray="${escapeAttr(clipDash)}"` : '') +
                         ` />`
                 );
             }
@@ -215,8 +190,15 @@ export const renderViewportElement = (
                 );
             }
         });
+        if (clipFill && clipFill !== 'none') {
+            clipDebugPolys.unshift(
+                `<path d="${ringDs.join(' ')}" fill-rule="evenodd" fill="${escapeAttr(clipFill)}"` +
+                    (clipFillOpacity !== undefined ? ` fill-opacity="${clipFillOpacity}"` : '') +
+                    ` stroke="none" />`
+            );
+        }
         parts.push(
-            `<defs><clipPath id="${clipId}" clipPathUnits="userSpaceOnUse">${polyPartsPage.join('')}</clipPath></defs>`
+            `<defs><clipPath id="${clipId}" clipPathUnits="userSpaceOnUse"><path d="${ringDs.join(' ')}" clip-rule="evenodd" /></clipPath></defs>`
         );
     }
 
@@ -225,35 +207,25 @@ export const renderViewportElement = (
 
     // Render fill polygons below structural lines
     const allowedGids = viewportHighlight[vp.id]?.gids ?? null;
-    const fillSvg = buildFillSvg(vp, dataWithViewport, model, allowedGids, legendColorMaps);
+    const fillSvg = buildFillSvg(vp, dataWithViewport, model, allowedGids, legendColorMaps, warnings, includeFilters);
     if (fillSvg) parts.push(fillSvg);
 
-    // Debug: log sample path coordinates from model.groupSvg
-    if (clipId && model.rawPaths && model.rawPaths.length > 0) {
-        const asMeta = (m: unknown): { isSegment?: boolean; isFill?: boolean; class?: string } | undefined =>
-            m != null && typeof m === 'object'
-                ? (m as { isSegment?: boolean; isFill?: boolean; class?: string })
-                : undefined;
-        const samplePath = model.rawPaths.find((p) => {
-            const pm = asMeta(p.meta);
-            return pm?.isSegment || (!pm?.isFill && !pm?.class);
-        });
-        if (samplePath) {
-            const dMatch = samplePath.d.match(/M([\d.-]+)\s+([\d.-]+)/);
-            if (dMatch) {
-                // console.log(`[DEBUG PATH vp="${vp.id}"] Sample wall path starts at x=${dMatch[1]} y=${dMatch[2]} (world coords, will be transformed by geometryTransform)`);
-            }
-        }
-    }
-
-    // Compensate stroke-widths for the viewport scale transform.
-    // Paths have stroke-width in model units; the scale(mmPerModel) transform
-    // would make them thinner/thicker depending on zoom. Dividing by mmPerModel
-    // ensures strokes render at their intended mm size regardless of viewport scale.
-    const compensatedSvg = model.groupSvg.replace(
-        /stroke-width="([0-9.eE+-]+)"/g,
-        (_, w) => `stroke-width="${parseFloat(w) / mmPerModel}"`
-    );
+    // Compensate stroke-widths AND dash arrays for the viewport scale
+    // transform. Path styling is authored in mm; the scale(mmPerModel)
+    // transform would multiply both, so divide them out — otherwise
+    // stroke-dasharray "4 2" means 4 model units (metres), not 4 mm, and the
+    // dash period changes with the viewport scale.
+    const compensatedSvg = model.groupSvg
+        .replace(/stroke-width="([0-9.eE+-]+)"/g, (_, w) => `stroke-width="${parseFloat(w) / mmPerModel}"`)
+        .replace(
+            /stroke-dasharray="([0-9.eE+\-, ]+)"/g,
+            (_, dashes: string) =>
+                `stroke-dasharray="${dashes
+                    .split(/[\s,]+/)
+                    .filter(Boolean)
+                    .map((d) => parseFloat(d) / mmPerModel)
+                    .join(' ')}"`
+        );
     parts.push(compensatedSvg);
     parts.push('</g>');
     parts.push('</g>');
@@ -282,30 +254,30 @@ export const renderViewportElement = (
         parts.push(
             `<rect x="${vp.xMm}" y="${vp.yMm}" width="${vp.widthMm}" height="${vp.heightMm}" stroke="${escapeAttr(
                 borderStroke
-            )}" stroke-width="${borderWidth}" fill="none"${vp.border.dashed ? ' stroke-dasharray="4 2"' : ''} />`
+            )}" stroke-width="${borderWidth}" fill="none"${vp.border.dash ? ` stroke-dasharray="${escapeAttr(vp.border.dash)}"` : ''} />`
         );
     }
 
     if (vp.northArrow) {
         const arrow = vp.northArrow;
-        const asset = assetMap.get(arrow.assetId);
+        const resource = resourceMap.get(arrow.resourceId);
         const size = arrow.sizeMm ?? 12;
         const offsetX = arrow.offsetXMm ?? 8;
         const offsetY = arrow.offsetYMm ?? 8;
         const arrowX = vp.xMm + vp.widthMm - offsetX - size;
         const arrowY = vp.yMm + offsetY;
         const arrowRotation = arrow.rotationDeg ?? 0;
-        if (!asset) {
-            warnings.push(`Missing asset '${arrow.assetId}' for north arrow on viewport '${vp.id}'.`);
-        } else if (asset.src) {
+        if (!resource) {
+            warnings.push(`Missing resource '${arrow.resourceId}' for north arrow on viewport '${vp.id}'.`);
+        } else if (resource.src) {
             parts.push(
-                `<image href="${escapeAttr(asset.src)}" x="${arrowX}" y="${arrowY}" width="${size}" height="${size}" transform="rotate(${arrowRotation}, ${arrowX + size / 2}, ${
+                `<image href="${escapeAttr(resource.src)}" x="${arrowX}" y="${arrowY}" width="${size}" height="${size}" transform="rotate(${arrowRotation}, ${arrowX + size / 2}, ${
                     arrowY + size / 2
                 })" />`
             );
-        } else if (asset.content) {
+        } else if (resource.content) {
             parts.push(
-                `<g transform="translate(${arrowX} ${arrowY}) rotate(${arrowRotation} ${size / 2} ${size / 2})">${asset.content}</g>`
+                `<g transform="translate(${arrowX} ${arrowY}) rotate(${arrowRotation} ${size / 2} ${size / 2})">${resource.content}</g>`
             );
         }
     }
@@ -327,7 +299,9 @@ function buildFillSvg(
     data: any,
     model: SvgModelView,
     allowedGids: Set<string> | null,
-    legendColorMaps?: Map<string, Map<string, string>>
+    legendColorMaps: Map<string, LegendColorAssignment> | undefined,
+    warnings: string[],
+    includeFilters?: ResolvedIncludeFilter[] | null
 ): string | null {
     const fills = vp.fills;
     if (!fills?.length || !model.transform) return null;
@@ -342,7 +316,7 @@ function buildFillSvg(
         const opacity = rule.fillOpacity ?? 0.35;
         // Find items matching this fill rule
         let matching = items.filter((item: unknown) =>
-            isRecord(item) ? matchesV2Filter(item, rule.class, rule.where) : false
+            isRecord(item) ? matchesFilter(item, rule.class, rule.where) : false
         );
 
         // Filter by allowed GIDs (from clip polygon center point test)
@@ -352,20 +326,23 @@ function buildFillSvg(
                 const gid = getProp(item, 'gid') ?? getProp(item, 'id');
                 return gid !== null && gid !== undefined && allowedGids.has(String(gid));
             });
-            // console.log(`[DEBUG FILL vp="${vp.id}"] Clip filter applied (matchClipFilter=true): ${beforeFilter} → ${matching.length} items (allowedGids.size=${allowedGids.size})`);
-        } else if (rule.matchClipFilter === true) {
-            // console.log(`[DEBUG FILL vp="${vp.id}"] Fill rule has matchClipFilter=true but no clip polygon active`);
+        } else if (includeFilters?.length) {
+            // The viewport's includeClasses gates generic fills exactly like it gates
+            // line paths — the include list is authoritative for what geometry appears.
+            // GID-gated rules (matchClipFilter with an active clip/highlight set, the
+            // branch above) are exempt, mirroring highlight/clip classes in
+            // filterModelForViewport: a clipped apartment's space fills must render
+            // even in a view whose includeClasses excludes spaces.
+            matching = matching.filter(
+                (item: unknown) =>
+                    isRecord(item) &&
+                    includeFilters.some((f) =>
+                        typeof f === 'string'
+                            ? matchesFilter(item, f, undefined)
+                            : matchesFilter(item, f.class, f.where)
+                    )
+            );
         }
-        // console.log(`[DEBUG FILL vp="${vp.id}"] Fill rule (class="${rule.class}", where=${JSON.stringify(rule.where)}) matched ${matching.length} items`);
-        // if (matching.length > 0) {
-        //   console.log(`[DEBUG FILL vp="${vp.id}"] First matched item:`, {
-        //     gid: getProp(matching[0], 'gid'),
-        //     name: getProp(matching[0], 'name'),
-        //     ifcClass: getProp(matching[0], 'ifcClass'),
-        //     propertySets: getProp(matching[0], 'propertySets'),
-        //     polylines: Array.isArray(getProp(matching[0], 'polylines')) ? (getProp(matching[0], 'polylines') as any[]).length : 0
-        //   });
-        // }
         if (!matching.length) continue;
 
         for (const item of matching) {
@@ -379,40 +356,33 @@ function buildFillSvg(
                 if (!color) continue; // no sampled color available
                 fillColor = `rgb(${color[0]},${color[1]},${color[2]})`;
             } else if (rule.fill === 'legend') {
-                // Use color from legend color map
-                const legendColorMap = legendColorMaps?.get(vp.id);
-                if (!legendColorMap) {
-                    console.warn(
-                        `[FILL] fill="legend" specified but no legend color map found for viewport "${vp.id}". Available viewports:`,
-                        Array.from(legendColorMaps?.keys() ?? [])
+                const legendColors = legendColorMaps?.get(vp.id);
+                if (!legendColors) {
+                    warnings.push(
+                        `Viewport '${vp.id}' has fill: "legend" but no legend with assignColors targets it (legends exist for: ${Array.from(legendColorMaps?.keys() ?? []).join(', ') || 'none'}).`
                     );
-                    continue;
+                    break;
+                }
+                // Resolve the item's colour: by item identity first (covers
+                // ungrouped legends — every item its own colour), then by the
+                // legend's groupBy property value (shared across a group).
+                let resolved: string | undefined;
+                const gid = getProp(item, 'gid') ?? getProp(item, 'id');
+                if (gid !== null && gid !== undefined) {
+                    resolved = legendColors.byGid.get(String(gid));
                 }
-                // Find matching legend entry - need to determine which property to use for lookup
-                // For now, try common properties (can be made configurable later)
-                let legendKey: string | undefined;
-                const possibleKeys = ['spacename', 'BIP.spacename', 'name'];
-                for (const key of possibleKeys) {
-                    const value = resolvePath(item, key);
+                if (!resolved && legendColors.groupBy) {
+                    const value = resolvePath(item, legendColors.groupBy);
                     if (value !== undefined && value !== null) {
-                        legendKey = String(value);
-                        break;
+                        resolved = legendColors.byValue.get(String(value));
                     }
                 }
-                if (!legendKey || !legendColorMap.has(legendKey)) {
-                    // No matching color in legend, skip this item
-                    // if (legendKey) {
-                    //   console.log(`[FILL] No color mapping for "${legendKey}" (property: ${matchedProperty}). Available keys:`, Array.from(legendColorMap.keys()));
-                    // }
-                    continue;
-                }
-                fillColor = legendColorMap.get(legendKey)!;
-                // console.log(`[FILL] ✓ Matched "${legendKey}" -> ${fillColor}`);
+                if (!resolved) continue; // item not represented in the legend
+                fillColor = resolved;
             } else {
                 fillColor = rule.fill;
             }
 
-            // console.log(`[FILL] Processing ${polylines.length} polyline(s) for item with color ${fillColor}`);
             for (const polyline of polylines) {
                 const points = isRecord(polyline) ? getProp(polyline, 'points') : null;
                 if (!Array.isArray(points) || points.length < 3) continue;
@@ -426,7 +396,11 @@ function buildFillSvg(
                     if (!Number.isFinite(px) || !Number.isFinite(pz)) continue;
                     const mx = (px as number) - viewMinX;
                     const my = viewMaxZ - (pz as number);
-                    pathParts.push(i === 0 ? `M ${mx} ${my}` : `L ${mx} ${my}`);
+                    pathParts.push(
+                        i === 0
+                            ? `M ${formatNumber(mx)} ${formatNumber(my)}`
+                            : `L ${formatNumber(mx)} ${formatNumber(my)}`
+                    );
                 }
                 if (pathParts.length < 3) continue;
                 pathParts.push('Z');
@@ -437,6 +411,5 @@ function buildFillSvg(
         }
     }
 
-    // console.log(`[FILL] Generated ${parts.length} fill polygon(s) for viewport "${vp.id}"`);
     return parts.length ? `<g>${parts.join('')}</g>` : null;
 }

package/src/layout/viewportUtils.ts

@@ -11,29 +11,142 @@ export const rotateBounds = (width: number, height: number, rotationDeg: number)
     return { width: rotatedWidth, height: rotatedHeight };
 };
 
+export interface RotatedContentExtents {
+    /** Tight extents of the rotated content, model units (rotated/sheet axes). */
+    width: number;
+    height: number;
+    /** Tight-bounds center mapped back to view space — the rotation pivot that centers the content. */
+    centerViewX: number;
+    centerViewY: number;
+}
+
+// Absolute move/line sequences only (what our section renderers emit). Anything
+// else — relative commands, curves, arcs — falls back to AABB-based rotation.
+const ABSOLUTE_POLYLINE_D = /^[MLZ\s,0-9eE+\-.]*$/;
+const NUMBER_IN_D = /-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+
+const extentsCache = new WeakMap<object, Map<string, RotatedContentExtents | null>>();
+
+/**
+ * Tight bounds of the model's actual geometry under viewport rotation.
+ *
+ * Rotating the model's AABB *rectangle* only ever inflates it — for content that
+ * sits diagonally in model space (the main reason to set rotationDeg: straighten
+ * a building on the sheet), the true rotated bounds SHRINK instead, and fitting
+ * against the inflated rectangle picks a scale several preset steps too small.
+ * Returns null when tight bounds can't be derived (no rotation, no rawPaths /
+ * transform, or path data that isn't plain absolute polylines) — callers then
+ * keep the AABB-based rotateBounds behavior.
+ */
+export const rotatedContentExtents = (model: SvgModelView, rotationDeg: number): RotatedContentExtents | null => {
+    const norm = ((rotationDeg % 360) + 360) % 360;
+    const paths = model.rawPaths;
+    const t = model.transform;
+    if (!norm || !paths?.length || !t) return null;
+    // Keyed on the transform origin as well as the rotation. The extents below are computed through
+    // t.viewMinX / t.viewMaxZ, so two models sharing a rawPaths array but placed with different
+    // origins have different answers — keying on rotation alone handed the second the first's.
+    const cacheKey = `${norm}|${t.viewMinX}|${t.viewMaxZ}`;
+    let perRotation = extentsCache.get(paths);
+    const cached = perRotation?.get(cacheKey);
+    if (cached !== undefined) return cached;
+    if (!perRotation) {
+        perRotation = new Map();
+        extentsCache.set(paths, perRotation);
+    }
+
+    const rad = (norm * Math.PI) / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const p of paths) {
+        if (!p.d) continue;
+        if (!ABSOLUTE_POLYLINE_D.test(p.d)) {
+            perRotation.set(cacheKey, null);
+            return null;
+        }
+        const nums = p.d.match(NUMBER_IN_D);
+        if (!nums) continue;
+        for (let i = 0; i + 1 < nums.length; i += 2) {
+            // Raw coords are projected y-up space; geometryTransform maps them to
+            // view space (y-down, origin at the model's min corner) — mirror that
+            // here so extents/center land in the space the render transform uses.
+            const vx = Number(nums[i]) - t.viewMinX;
+            const vy = t.viewMaxZ - Number(nums[i + 1]);
+            const rx = vx * cos - vy * sin;
+            const ry = vx * sin + vy * cos;
+            if (rx < minX) minX = rx;
+            if (rx > maxX) maxX = rx;
+            if (ry < minY) minY = ry;
+            if (ry > maxY) maxY = ry;
+        }
+    }
+    if (!Number.isFinite(minX) || !Number.isFinite(minY) || maxX - minX <= 0 || maxY - minY <= 0) {
+        perRotation.set(cacheKey, null);
+        return null;
+    }
+    const cx = (minX + maxX) / 2;
+    const cy = (minY + maxY) / 2;
+    const result: RotatedContentExtents = {
+        width: maxX - minX,
+        height: maxY - minY,
+        // Inverse-rotate the rotated-space center: using this as the transform
+        // pivot makes the tight content box land centered in the viewport.
+        centerViewX: cx * cos + cy * sin,
+        centerViewY: -cx * sin + cy * cos
+    };
+    perRotation.set(cacheKey, result);
+    return result;
+};
+
 export const pickScale = (
     viewport: ViewportElement,
     model: SvgModelView,
     preferred: number[],
     scalePresets: Record<string, { preferredScales?: number[] }>
 ): ComputedViewportScale => {
+    const rotationDeg = viewport.rotationDeg ?? 0;
+    // Callers substitute clip-region dims into widthModel/heightModel; tight
+    // rotated bounds of the FULL geometry would be wrong there, so only use
+    // them when the passed dims still match the model's own view bounds.
+    const clipAdjusted =
+        !!model.transform &&
+        (Math.abs(model.widthModel - model.transform.viewWidth) > 1e-9 ||
+            Math.abs(model.heightModel - model.transform.viewHeight) > 1e-9);
+    const tight = clipAdjusted ? null : rotatedContentExtents(model, rotationDeg);
+
+    // 'fit': exact fill of the viewport — the denominator is whatever ratio
+    // makes the (rotated) model touch the viewport bounds; no rounding to a
+    // preferred-scale list, so the scale text can be odd (e.g. 1:73.4).
+    if (viewport.scaleMode === 'fit') {
+        const rotatedModel = tight ?? rotateBounds(model.widthModel, model.heightModel, rotationDeg);
+        const mmPerModel = Math.min(
+            viewport.widthMm / (rotatedModel.width || 1),
+            viewport.heightMm / (rotatedModel.height || 1)
+        );
+        if (Number.isFinite(mmPerModel) && mmPerModel > 0) {
+            return { denom: Math.round((1000 / mmPerModel) * 10) / 10, mmPerModelUnit: mmPerModel, fits: true };
+        }
+    }
+
     const scalePresetName = viewport.scalePreset;
     const scalePreset = scalePresetName && scalePresets[scalePresetName] ? scalePresets[scalePresetName] : null;
     const denoms =
         viewport.scaleMode === 'fixed' && viewport.fixedScaleDenom
             ? [viewport.fixedScaleDenom]
             : uniquePositiveDenoms(viewport.preferredScales ?? scalePreset?.preferredScales ?? preferred);
-
-    const rotationDeg = viewport.rotationDeg ?? 0;
     let selectedDenom = denoms[denoms.length - 1];
     let selectedMmPerModel = 1000 / selectedDenom;
     let fits = false;
 
     for (const denom of denoms) {
         const mmPerModel = 1000 / denom;
-        const widthMm = model.widthModel * mmPerModel;
-        const heightMm = model.heightModel * mmPerModel;
-        const rotated = rotateBounds(widthMm, heightMm, rotationDeg);
+        const rotated = tight
+            ? { width: tight.width * mmPerModel, height: tight.height * mmPerModel }
+            : rotateBounds(model.widthModel * mmPerModel, model.heightModel * mmPerModel, rotationDeg);
         if (rotated.width <= viewport.widthMm && rotated.height <= viewport.heightMm) {
             selectedDenom = denom;
             selectedMmPerModel = mmPerModel;