@twinfinity/printing 6.0.1-ci.28952-beta → 6.0.2-beta

package/src/sections.ts

@@ -1,1019 +1,1019 @@
-import type {
-    Vec3,
-    SectionLabel,
-    SectionPath,
-    SectionRenderState,
-    TransformInfo,
-    ViewWindow
-} from '@twinfinity/geometry';
-
-export type { SectionLabel, SectionPath, SectionRenderState, TransformInfo, ViewWindow } from '@twinfinity/geometry';
-
-/** Minimal product interface for section fill matching. */
-interface SectionProduct {
-    class?: { is(c: unknown): boolean; type?: string; id?: string };
-    className?: string;
-    propertySets?: Record<string, unknown>;
-    properties?: { data?: Record<string, unknown>; sets?: Record<string, unknown> };
-}
-
-/** Local replacement for PlaneSectionEntry (not available in @twinfinity/geometry). */
-type PlaneSectionEntry<TProduct extends SectionProduct = SectionProduct> = {
-    product: TProduct;
-    segments: [Vec3, Vec3][];
-    polylines: { points: Vec3[]; closed: boolean }[];
-};
-
-/**
- * Resolve a dotted property path (e.g. "BIP.spacetype") against a product.
- * Handles both the new T8 API (propertySets → .properties → .value) and
- * legacy BimIfcObject (properties.sets / properties.data).
- *
- * Returns the resolved value, or undefined if not found.
- */
-export function resolveProductProperty(product: SectionProduct | unknown, path: string): unknown {
-    const p = product as SectionProduct;
-    const parts = path.split('.');
-    if (parts.length < 2) return undefined;
-
-    const [setName, ...propParts] = parts;
-    const propName = propParts.join('.');
-
-    // New T8 API: propertySets['BIP'].properties['spacetype'].value
-    const pset = (p?.propertySets as Record<string, any>)?.[setName];
-    if (pset) {
-        const prop = pset.properties?.[propName];
-        if (prop !== undefined) {
-            return prop?.value !== undefined ? prop.value : prop;
-        }
-    }
-
-    // Legacy: properties.sets['BIP']['spacetype']
-    const legacyPset = (p?.properties?.sets as Record<string, any>)?.[setName];
-    if (legacyPset) {
-        const val = legacyPset[propName];
-        if (val !== undefined) {
-            return val?.value !== undefined ? val.value : val;
-        }
-    }
-
-    // Fallback: properties.data['BIP']['spacetype'] (old printing code path)
-    let value: any = p?.properties?.data;
-    if (value) {
-        for (const part of parts) {
-            value = value?.[part];
-            if (value === undefined) break;
-        }
-        if (value !== undefined) {
-            return value?.value !== undefined ? value.value : value;
-        }
-    }
-
-    return undefined;
-}
-
-/**
- * Sample the actual rendered color of a product's first mesh.
- * Uses BimProductMesh.copyColorTo/getColorComponent for accurate colors
- * (includes overrides, highlights). Falls back to style.surfaceColor/color.
- */
-const sampleProductColorRgba = (product: unknown): { r: number; g: number; b: number; a: number } | undefined => {
-    /** Duck-typed mesh with optional color-access methods. */
-    interface DuckMesh {
-        copyColorTo?: (out: Uint8Array, offset: number) => void;
-        getColorComponent?: (index: number) => number;
-        style?: { surfaceColor?: readonly number[]; color?: readonly number[] };
-    }
-    const p = product as Record<string, unknown>;
-    const meshes = (p?.meshes ?? p?.productMeshes) as DuckMesh[] | undefined;
-    if (!meshes || !meshes.length) return undefined;
-
-    const rgba = new Uint8Array(4);
-
-    for (const mesh of meshes) {
-        try {
-            // BimProductMesh: read actual rendered color via copyColorTo or getColorComponent
-            if (typeof mesh.copyColorTo === 'function') {
-                mesh.copyColorTo(rgba, 0);
-            } else if (typeof mesh.getColorComponent === 'function') {
-                rgba[0] = mesh.getColorComponent(0); // Red
-                rgba[1] = mesh.getColorComponent(1); // Green
-                rgba[2] = mesh.getColorComponent(2); // Blue
-                rgba[3] = mesh.getColorComponent(3); // Alpha
-            } else {
-                // ModelMesh fallback: read from style
-                const style = mesh.style;
-                const c = style?.surfaceColor ?? style?.color;
-                if (c) return { r: c[0], g: c[1], b: c[2], a: (c[3] ?? 255) / 255 };
-                continue;
-            }
-        } catch {
-            continue;
-        }
-
-        const [r, g, b, a] = rgba;
-        if (a === 0 && r === 0 && g === 0 && b === 0) continue;
-        return { r, g, b, a: a / 255 };
-    }
-
-    return undefined;
-};
-
-/** Base SVG display width in layout units. */
-export const BASE_WIDTH = 240;
-/** Minimum SVG display height in layout units. */
-export const MIN_HEIGHT = 140;
-/** Margin ratio applied around section bounds (fraction of world extent). */
-export const SECTION_MARGIN_RATIO = 0.05;
-/** Maximum zoom factor for viewport clamping. */
-export const MAX_ZOOM_FACTOR = 12;
-/** Multiplicative step for zooming in. */
-export const ZOOM_IN_STEP = 0.8;
-/** Multiplicative step for zooming out. */
-export const ZOOM_OUT_STEP = 1 / ZOOM_IN_STEP;
-const OUTLINE_THICKNESS_SCALE = 0.5;
-
-/** Clamp a number to a min/max range. */
-export function clampValue(value: number, min: number, max: number): number {
-    return Math.min(max, Math.max(min, value));
-}
-
-export interface SectionBuildOptions {
-    /** If true, attach source product metadata to paths/labels for downstream filtering */
-    includeMeta?: boolean;
-    /** When true, create fill paths for closed polygons. When false, create only stroke/outline paths. Defaults to true for backward compatibility. */
-    createFills?: boolean;
-    /** Plane normal vector for determining 2D projection axes. If omitted, defaults to horizontal plan (Y-up). */
-    planeNormal?: Vec3;
-}
-
-/**
- * Extract product metadata for path/label attribution.
- * Casts to `any` once here to avoid scattering `as any` across the codebase.
- * BimIfcObject's runtime shape exposes these fields but the public typings
- * don't always surface them.
- */
-function extractProductMeta(product: unknown): {
-    productId: string;
-    ifcClass: string | null;
-    ifcClassId: string | null;
-    properties: unknown;
-} {
-    const p = product as Record<string, any>;
-    return {
-        productId: p?.gid ?? p?.id ?? String(product),
-        ifcClass: p?.class?.type ?? null,
-        ifcClassId: p?.class?.id ?? null,
-        properties: p?.properties?.data ?? p?.properties ?? null
-    };
-}
-
-/** Default fill opacity when a fill rule omits `fillOpacity`. */
-export const DEFAULT_FILL_OPACITY = 0.35;
-
-/**
- * Fill rule controlling which products get visible fills and at what opacity.
- * Mirrors the template-level FillRule but kept minimal to avoid circular deps.
- */
-export interface SectionFillRule {
-    /** IFC class filter. When omitted, matches all products. */
-    class?: string | string[];
-    /** Property-based filter (e.g. { "BIP.spacetype": "ROOM" }). */
-    where?: Record<string, string | number | boolean | Array<string | number>>;
-    /** Fill opacity (0–1). Default: {@link DEFAULT_FILL_OPACITY}. */
-    fillOpacity?: number;
-    /** When true, only apply fill to products whose centroid is inside the clip polygon. @default false */
-    matchClipFilter?: boolean;
-}
-
-export interface BuildSectionStateOptions {
-    viewport?: ViewWindow;
-    strokeWidth?: number;
-    labelFontSize?: number;
-    /**
-     * Fill rules controlling which products get visible fills and at what opacity.
-     * Products matching a fill rule are rendered below non-matching products.
-     * When absent or empty, all products render uniformly (no fill-based reordering).
-     */
-    fills?: SectionFillRule[];
-    includeMeta?: boolean;
-    /** Enable labels. Requires buildLabels callback. */
-    includeLabels?: boolean;
-    /** Callback to build labels for matching products. Required when includeLabels is true. */
-    buildLabels?: (products: any[], fontSize: number) => SectionLabel[];
-    /** Clip polygon in world coordinates (x, z). Used when fill.matchClipFilter is true for spatial filtering. */
-    clipPolygon?: Array<Array<{ x: number; z: number }>>;
-    /** When true, create fill paths for closed polygons. When false, create only stroke/outline paths. Defaults to true for backward compatibility. */
-    createFills?: boolean;
-    /** Plane normal vector for determining 2D projection axes. If omitted, defaults to horizontal plan (Y-up). */
-    planeNormal?: Vec3;
-}
-
-/** Convert plane section polylines to SVG path data with fill colors and stroke styles. */
-export function createSectionSvg(
-    perProduct: PlaneSectionEntry[],
-    viewport?: ViewWindow,
-    strokeWidthHint?: number,
-    labels?: SectionLabel[],
-    options?: SectionBuildOptions
-): SectionRenderState | null {
-    if (!perProduct.length) {
-        return null;
-    }
-
-    const polylines = perProduct.flatMap((entry) => entry.polylines);
-    const hasSegments = perProduct.some((entry) => entry.segments && entry.segments.length > 0);
-
-    if (!polylines.length && !hasSegments) {
-        return null;
-    }
-
-    const planeNormal = options?.planeNormal;
-    const axes = getProjectionAxes(planeNormal);
-
-    let viewMinX: number;
-    let viewMaxX: number;
-    let viewMinZ: number;
-    let viewMaxZ: number;
-
-    if (viewport) {
-        viewMinX = viewport.viewMinX;
-        viewMaxX = viewport.viewMaxX;
-        viewMinZ = viewport.viewMinZ;
-        viewMaxZ = viewport.viewMaxZ;
-    } else {
-        let minU = Number.POSITIVE_INFINITY;
-        let maxU = Number.NEGATIVE_INFINITY;
-        let minV = Number.POSITIVE_INFINITY;
-        let maxV = Number.NEGATIVE_INFINITY;
-
-        polylines.forEach((polyline: { points: Vec3[]; closed: boolean }) => {
-            polyline.points.forEach((point: Vec3) => {
-                if (!point) {
-                    return;
-                }
-                const u = axes.getU(point);
-                const v = axes.getV(point);
-                if (!Number.isFinite(u) || !Number.isFinite(v)) {
-                    return;
-                }
-                if (u < minU) minU = u;
-                if (u > maxU) maxU = u;
-                if (v < minV) minV = v;
-                if (v > maxV) maxV = v;
-            });
-        });
-
-        // Also include segments in bounding box calculation
-        perProduct.forEach((entry) => {
-            if (entry.segments && entry.segments.length) {
-                entry.segments.forEach((segment) => {
-                    const [p1, p2] = segment;
-                    const u1 = axes.getU(p1);
-                    const v1 = axes.getV(p1);
-                    const u2 = axes.getU(p2);
-                    const v2 = axes.getV(p2);
-                    if (Number.isFinite(u1) && Number.isFinite(v1)) {
-                        if (u1 < minU) minU = u1;
-                        if (u1 > maxU) maxU = u1;
-                        if (v1 < minV) minV = v1;
-                        if (v1 > maxV) maxV = v1;
-                    }
-                    if (Number.isFinite(u2) && Number.isFinite(v2)) {
-                        if (u2 < minU) minU = u2;
-                        if (u2 > maxU) maxU = u2;
-                        if (v2 < minV) minV = v2;
-                        if (v2 > maxV) maxV = v2;
-                    }
-                });
-            }
-        });
-
-        if (!Number.isFinite(minU) || !Number.isFinite(maxU) || !Number.isFinite(minV) || !Number.isFinite(maxV)) {
-            return null;
-        }
-
-        if (maxU - minU < 1e-3) {
-            minU -= 0.5;
-            maxU += 0.5;
-        }
-        if (maxV - minV < 1e-3) {
-            minV -= 0.5;
-            maxV += 0.5;
-        }
-
-        const worldWidth = maxU - minU;
-        const worldHeight = maxV - minV;
-        const marginU = Math.max(worldWidth * SECTION_MARGIN_RATIO, 0.5);
-        const marginV = Math.max(worldHeight * SECTION_MARGIN_RATIO, 0.5);
-
-        viewMinX = minU - marginU;
-        viewMaxX = maxU + marginU;
-        viewMinZ = minV - marginV;
-        viewMaxZ = maxV + marginV;
-    }
-
-    const viewWidth = viewMaxX - viewMinX;
-    const viewHeight = viewMaxZ - viewMinZ;
-
-    if (!Number.isFinite(viewWidth) || !Number.isFinite(viewHeight) || viewWidth <= 1e-6 || viewHeight <= 1e-6) {
-        return null;
-    }
-
-    const autoStrokeBase = Math.max(Math.min(viewWidth, viewHeight) * 0.008, 0.08);
-    const autoStroke = Math.max(autoStrokeBase * OUTLINE_THICKNESS_SCALE, 0.02);
-    const strokeWidth = Math.max(strokeWidthHint ?? autoStroke, 0.02);
-    const geometryTransform = buildGeometryTransform(viewMinX, viewMaxX, viewMinZ, viewMaxZ);
-
-    const includeMeta = !!options?.includeMeta;
-    const createFills = options?.createFills !== false; // Default to true for backward compatibility
-
-    const allPaths: SectionPath[] = [];
-    if (includeMeta) {
-        perProduct.forEach((entry, idx) => {
-            // Skip entries with neither polylines nor segments
-            if (!entry.polylines.length && (!entry.segments || !entry.segments.length)) {
-                return;
-            }
-            const colorInfo = sampleProductColorRgba(entry.product);
-            const fillColor = colorInfo ? `rgb(${colorInfo.r},${colorInfo.g},${colorInfo.b})` : '#ffffff';
-            const fillOpacity = colorInfo ? clampValue(colorInfo.a, 0, 1) : 1;
-            const meta = extractProductMeta(entry.product);
-
-            const closedSubpaths: string[] = [];
-            const holeSubpaths: string[] = [];
-            const openSubpaths: string[] = [];
-
-            entry.polylines.forEach((polyline) => {
-                const pathData = getCachedPolylinePath(polyline, planeNormal);
-                if (!pathData) {
-                    return;
-                }
-                if (pathData.closed) {
-                    if (pathData.hole) {
-                        holeSubpaths.push(pathData.d);
-                    } else {
-                        closedSubpaths.push(pathData.d);
-                    }
-                } else {
-                    openSubpaths.push(pathData.d);
-                }
-            });
-
-            // Only create fill paths if createFills is true
-            if (createFills && (closedSubpaths.length || holeSubpaths.length)) {
-                const fillSubpaths = closedSubpaths.length ? closedSubpaths.concat(holeSubpaths) : holeSubpaths;
-                allPaths.push({
-                    key: `fill-${idx}`,
-                    d: fillSubpaths.join(' '),
-                    fill: fillColor,
-                    fillOpacity: clampValue(fillOpacity, 0, 1),
-                    stroke: '#1f2937',
-                    strokeWidth,
-                    fillRule: 'evenodd',
-                    meta: meta ? { ...meta, isFill: true } : undefined
-                });
-            }
-
-            if (openSubpaths.length) {
-                allPaths.push({
-                    key: `outline-${idx}`,
-                    d: openSubpaths.join(' '),
-                    fill: 'none',
-                    fillOpacity: 1,
-                    stroke: '#1f2937',
-                    strokeWidth,
-                    meta: meta ? { ...meta, isOutline: true } : undefined
-                });
-            }
-
-            // Render segments (cut edges) as strokes
-            if (entry.segments && entry.segments.length) {
-                const segmentPaths: string[] = [];
-                for (const segment of entry.segments) {
-                    const path = segmentToPath(segment, planeNormal);
-                    if (path) segmentPaths.push(path);
-                }
-                if (segmentPaths.length) {
-                    allPaths.push({
-                        key: `segments-${idx}`,
-                        d: segmentPaths.join(' '),
-                        fill: 'none',
-                        fillOpacity: 1,
-                        stroke: '#1f2937',
-                        strokeWidth,
-                        meta: meta ? { ...meta, isSegment: true } : undefined
-                    });
-                }
-            }
-        });
-    } else {
-        const fillGroups = new Map<string, FillGroup>();
-        const openSubpaths: string[] = [];
-        const allSegmentPaths: string[] = [];
-
-        perProduct.forEach((entry) => {
-            // Process segments first (always render, even without polylines)
-            if (entry.segments && entry.segments.length) {
-                for (const segment of entry.segments) {
-                    const path = segmentToPath(segment, planeNormal);
-                    if (path) allSegmentPaths.push(path);
-                }
-            }
-
-            if (!entry.polylines.length) {
-                return;
-            }
-
-            const colorInfo = sampleProductColorRgba(entry.product);
-            const fillColor = colorInfo ? `rgb(${colorInfo.r},${colorInfo.g},${colorInfo.b})` : '#ffffff';
-            const fillOpacity = colorInfo ? clampValue(colorInfo.a, 0, 1) : 1;
-            const groupKey = `${fillColor}|${Math.round(fillOpacity * 1000)}`;
-            let group = fillGroups.get(groupKey);
-            if (!group) {
-                group = {
-                    color: fillColor,
-                    opacity: fillOpacity,
-                    closed: [],
-                    holes: []
-                };
-                fillGroups.set(groupKey, group);
-            }
-
-            entry.polylines.forEach((polyline) => {
-                const pathData = getCachedPolylinePath(polyline, planeNormal);
-                if (!pathData) {
-                    return;
-                }
-                if (pathData.closed) {
-                    if (pathData.hole) {
-                        group!.holes.push(pathData.d);
-                    } else {
-                        group!.closed.push(pathData.d);
-                    }
-                    return;
-                }
-                openSubpaths.push(pathData.d);
-            });
-        });
-
-        let groupIndex = 0;
-        fillGroups.forEach((group) => {
-            const fillSubpaths = group.closed.length ? group.closed.concat(group.holes) : group.holes;
-            if (!fillSubpaths.length) {
-                return;
-            }
-            allPaths.push({
-                key: `fill-${groupIndex++}`,
-                d: fillSubpaths.join(' '),
-                fill: group.color,
-                fillOpacity: clampValue(group.opacity, 0, 1),
-                stroke: '#1f2937',
-                strokeWidth,
-                fillRule: 'evenodd'
-            });
-        });
-
-        if (openSubpaths.length) {
-            allPaths.push({
-                key: 'outlines',
-                d: openSubpaths.join(' '),
-                fill: 'none',
-                fillOpacity: 1,
-                stroke: '#1f2937',
-                strokeWidth
-            });
-        }
-
-        // Render all segments (collected above in forEach loop)
-        if (allSegmentPaths.length) {
-            allPaths.push({
-                key: 'segments',
-                d: allSegmentPaths.join(' '),
-                fill: 'none',
-                fillOpacity: 1,
-                stroke: '#1f2937',
-                strokeWidth
-            });
-        }
-    }
-
-    if (!allPaths.length) {
-        return null;
-    }
-
-    const displayWidth = BASE_WIDTH;
-    const displayHeight = Math.max(MIN_HEIGHT, (viewHeight / viewWidth) * BASE_WIDTH);
-
-    return {
-        paths: allPaths,
-        transform: {
-            viewMinX,
-            viewMaxX,
-            viewMinZ,
-            viewMaxZ,
-            viewWidth,
-            viewHeight,
-            displayWidth,
-            displayHeight
-        },
-        strokeWidth,
-        geometryTransform,
-        labels: labels?.length
-            ? labels
-                  .filter((label) => {
-                      if (!Number.isFinite(label.x) || !Number.isFinite(label.z)) {
-                          return false;
-                      }
-                      return label.x >= viewMinX && label.x <= viewMaxX && label.z >= viewMinZ && label.z <= viewMaxZ;
-                  })
-                  .map((label) => ({
-                      key: label.key,
-                      text: label.text,
-                      x: label.x,
-                      y: label.y,
-                      z: label.z,
-                      fontSize: label.fontSize,
-                      meta: includeMeta ? (label.meta ?? {}) : undefined
-                  }))
-            : []
-    };
-}
-
-/**
- * Build a complete SectionRenderState from plane section entries, with optional
- * fill-rule-based separation, ordering, and label generation.
- *
- * When `fills` rules are provided, entries matching a fill rule are rendered
- * below non-matching entries, with their fill opacity set by the matching rule.
- */
-export function buildSectionStateForEntries(
-    perProduct: PlaneSectionEntry[],
-    options: BuildSectionStateOptions
-): (SectionRenderState & { rawPaths?: SectionPath[]; rawLabels?: SectionLabel[] }) | null {
-    if (!perProduct.length) {
-        return null;
-    }
-
-    const fills = options.fills;
-    const includeMeta = !!options?.includeMeta;
-    const includeLabels = options?.includeLabels ?? false;
-    const viewport = options?.viewport;
-    const strokeWidth = options?.strokeWidth;
-    const labelFontSize = includeLabels && typeof options?.labelFontSize === 'number' ? options.labelFontSize : null;
-    const buildLabels = options?.buildLabels;
-
-    // Point-in-polygon test (ray casting algorithm)
-    const pointInPolygon = (polygon: Array<{ x: number; z: number }>, x: number, z: number): boolean => {
-        let inside = false;
-        for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-            const xi = polygon[i].x;
-            const zi = polygon[i].z;
-            const xj = polygon[j].x;
-            const zj = polygon[j].z;
-            const intersect = zi > z !== zj > z && x < ((xj - xi) * (z - zi)) / (zj - zi) + xi;
-            if (intersect) inside = !inside;
-        }
-        return inside;
-    };
-
-    // Calculate centroid from entry's polylines
-    const getCentroid = (entry: PlaneSectionEntry): { x: number; z: number } | null => {
-        const polylines = entry.polylines;
-        if (!polylines.length) return null;
-        let sumX = 0;
-        let sumZ = 0;
-        let count = 0;
-        for (const polyline of polylines) {
-            for (const point of polyline.points) {
-                sumX += point[0];
-                sumZ += point[2];
-                count++;
-            }
-        }
-        if (count === 0) return null;
-        return { x: sumX / count, z: sumZ / count };
-    };
-
-    // Spatial matcher for clip filter - checks if product centroid is inside clip polygon
-    const isInsideClipPolygon = (entry: PlaneSectionEntry): boolean => {
-        if (!options?.clipPolygon?.length) return true;
-        const centroid = getCentroid(entry);
-        if (!centroid) return false;
-        // Check if centroid is inside any of the clip polygons
-        return options.clipPolygon.some((polygon) => pointInPolygon(polygon, centroid.x, centroid.z));
-    };
-
-    // Match an entry against fill rules. Returns the first matching rule, or undefined.
-    const matchFillRule = (entry: PlaneSectionEntry): SectionFillRule | undefined => {
-        if (!fills?.length) return undefined;
-        const product = entry.product;
-        for (const rule of fills) {
-            // If rule requires clip filter match, check if product centroid is inside clip polygon
-            if (rule.matchClipFilter && !isInsideClipPolygon(entry)) {
-                continue;
-            }
-
-            // Check class match
-            let classMatches: boolean;
-            if (rule.class) {
-                const classes = Array.isArray(rule.class) ? rule.class : [rule.class];
-                const cls = product.class;
-                classMatches = classes.some((c) => {
-                    if (cls?.is) return cls.is(c as string);
-                    const pName = (product.className ?? '').toLowerCase();
-                    return pName === (c as string).toLowerCase() || pName === `ifc${(c as string).toLowerCase()}`;
-                });
-                if (!classMatches) continue;
-            }
-
-            // Check where condition (property-based filter)
-            if (rule.where && Object.keys(rule.where).length > 0) {
-                let whereMatches = true;
-                for (const [path, expected] of Object.entries(rule.where)) {
-                    const actualValue = resolveProductProperty(product, path);
-                    if (actualValue === undefined) {
-                        whereMatches = false;
-                        break;
-                    }
-
-                    const normalize = (v: unknown): unknown => (typeof v === 'string' ? v.toLowerCase().trim() : v);
-
-                    if (Array.isArray(expected)) {
-                        if (!expected.some((exp) => normalize(exp) === normalize(actualValue))) {
-                            whereMatches = false;
-                            break;
-                        }
-                    } else {
-                        if (normalize(actualValue) !== normalize(expected)) {
-                            whereMatches = false;
-                            break;
-                        }
-                    }
-                }
-                if (!whereMatches) continue;
-            }
-
-            return rule;
-        }
-        return undefined;
-    };
-
-    const hasFills = !!fills?.length;
-
-    // Split entries by fill rule match
-    const fillEntries: PlaneSectionEntry[] = [];
-    const fillOpacities: number[] = []; // parallel to fillEntries
-    const nonFillEntries: PlaneSectionEntry[] = [];
-
-    for (const entry of perProduct) {
-        const rule = hasFills ? matchFillRule(entry) : undefined;
-        if (rule) {
-            const opacity = rule.fillOpacity ?? DEFAULT_FILL_OPACITY;
-            // Skip entries with zero opacity - don't render them at all
-            if (opacity > 0) {
-                fillEntries.push(entry);
-                fillOpacities.push(opacity);
-            }
-        } else {
-            nonFillEntries.push(entry);
-        }
-    }
-
-    // Build labels from fill-matched entries (e.g. spaces)
-    const fillLabels =
-        includeLabels && fillEntries.length && labelFontSize !== null && buildLabels
-            ? (buildLabels(
-                  fillEntries.map((entry) => entry.product),
-                  labelFontSize
-              ) as SectionLabel[])
-            : undefined;
-
-    // When fill rules are present, render fill and non-fill groups separately
-    // so we can adjust opacity and control ordering.
-    // When no fill rules, render everything in one pass (unchanged behavior).
-    if (hasFills && (fillEntries.length > 0 || nonFillEntries.length > 0)) {
-        const nonFillState =
-            nonFillEntries.length > 0
-                ? createSectionSvg(nonFillEntries, viewport, strokeWidth, undefined, {
-                      includeMeta,
-                      planeNormal: options.planeNormal
-                  })
-                : null;
-        const fillState =
-            fillEntries.length > 0
-                ? createSectionSvg(fillEntries, viewport, strokeWidth, includeLabels ? fillLabels : undefined, {
-                      includeMeta,
-                      planeNormal: options.planeNormal
-                  })
-                : null;
-
-        const baseState = nonFillState ?? fillState ?? null;
-        if (!baseState) return null;
-
-        // Adjust fill opacity per-entry. When includeMeta is true, each entry has
-        // its own path, so we can apply per-entry opacity. When false, paths are
-        // grouped by color — apply the minimum matching opacity.
-        const adjustedFillPaths =
-            fillState?.paths.map((path, idx) => {
-                // When fill rules match, use the rule opacity directly (don't multiply by material alpha).
-                // Material alpha was useful for auto-coloring, but fill rules should have full control.
-                const ruleOpacity = idx < fillOpacities.length ? fillOpacities[idx] : (fills![0]?.fillOpacity ?? 0.35);
-                const finalOpacity = clampValue(ruleOpacity, 0, 1);
-                return {
-                    ...path,
-                    fillOpacity: finalOpacity
-                };
-            }) ?? [];
-
-        const nonFillPaths = nonFillState?.paths ?? [];
-        // Fill-matched entries always render below non-fill entries
-        const mergedPaths = [...adjustedFillPaths, ...nonFillPaths];
-
-        const merged: SectionRenderState & { rawPaths?: SectionPath[]; rawLabels?: SectionLabel[] } = {
-            ...baseState,
-            paths: mergedPaths,
-            labels: includeLabels ? (fillState?.labels ?? fillLabels ?? []) : []
-        };
-
-        return merged;
-    }
-
-    // No fill rules — create paths with fills for highlight support, but set opacity to 0
-    const state = createSectionSvg(perProduct, viewport, strokeWidth, includeLabels ? fillLabels : undefined, {
-        includeMeta,
-        createFills: true,
-        planeNormal: options.planeNormal
-    });
-    if (!state) return null;
-
-    // Set all fill opacities to 0 when no fill rules exist (but keep paths for highlight support)
-    const pathsWithZeroFillOpacity = state.paths.map((path) => ({
-        ...path,
-        fillOpacity: 0
-    }));
-
-    return {
-        ...state,
-        paths: pathsWithZeroFillOpacity,
-        labels: includeLabels ? (state.labels ?? []) : []
-    };
-}
-
-/** Extract the viewport bounding box from a TransformInfo. */
-export function extractViewWindow(transform: TransformInfo): ViewWindow {
-    return {
-        viewMinX: transform.viewMinX,
-        viewMaxX: transform.viewMaxX,
-        viewMinZ: transform.viewMinZ,
-        viewMaxZ: transform.viewMaxZ
-    };
-}
-
-/** Compare two viewport windows for equality within a tolerance. */
-export function windowsEqual(a: ViewWindow, b: ViewWindow, epsilon = 1e-4): boolean {
-    return (
-        Math.abs(a.viewMinX - b.viewMinX) <= epsilon &&
-        Math.abs(a.viewMaxX - b.viewMaxX) <= epsilon &&
-        Math.abs(a.viewMinZ - b.viewMinZ) <= epsilon &&
-        Math.abs(a.viewMaxZ - b.viewMaxZ) <= epsilon
-    );
-}
-
-/** Constrain a viewport window within base bounds, preserving aspect ratio. */
-export function clampViewWindow(base: TransformInfo, candidate: ViewWindow): ViewWindow {
-    const baseWidth = base.viewWidth;
-    const baseHeight = base.viewHeight;
-    const aspect = baseWidth / baseHeight;
-
-    let width = candidate.viewMaxX - candidate.viewMinX;
-
-    if (!Number.isFinite(width) || width <= 1e-6) {
-        width = baseWidth;
-    }
-    width = clampValue(width, baseWidth / MAX_ZOOM_FACTOR, baseWidth);
-    const height = width / aspect;
-
-    let centerX = (candidate.viewMinX + candidate.viewMaxX) * 0.5;
-    if (!Number.isFinite(centerX)) {
-        centerX = (base.viewMinX + base.viewMaxX) * 0.5;
-    }
-
-    let centerZ = (candidate.viewMinZ + candidate.viewMaxZ) * 0.5;
-    if (!Number.isFinite(centerZ)) {
-        centerZ = (base.viewMinZ + base.viewMaxZ) * 0.5;
-    }
-
-    let minX = centerX - width * 0.5;
-    let maxX = minX + width;
-    if (minX < base.viewMinX) {
-        minX = base.viewMinX;
-        maxX = minX + width;
-    }
-    if (maxX > base.viewMaxX) {
-        maxX = base.viewMaxX;
-        minX = maxX - width;
-    }
-
-    let minZ = centerZ - height * 0.5;
-    let maxZ = minZ + height;
-    if (minZ < base.viewMinZ) {
-        minZ = base.viewMinZ;
-        maxZ = minZ + height;
-    }
-    if (maxZ > base.viewMaxZ) {
-        maxZ = base.viewMaxZ;
-        minZ = maxZ - height;
-    }
-
-    return {
-        viewMinX: minX,
-        viewMaxX: maxX,
-        viewMinZ: minZ,
-        viewMaxZ: maxZ
-    };
-}
-
-/** Adjust stroke width proportionally to zoom level. */
-export function strokeWidthForWindow(baseStroke: number, baseTransform: TransformInfo, window: ViewWindow): number {
-    const baseWidth = baseTransform.viewWidth;
-    const currentWidth = window.viewMaxX - window.viewMinX;
-    if (!Number.isFinite(baseWidth) || baseWidth <= 1e-6 || !Number.isFinite(currentWidth) || currentWidth <= 1e-6) {
-        return baseStroke;
-    }
-    const ratio = clampValue(currentWidth / baseWidth, 1 / MAX_ZOOM_FACTOR, 1);
-    const scaled = baseStroke * ratio;
-    return Math.max(scaled, baseStroke / (MAX_ZOOM_FACTOR + 1));
-}
-
-interface SvgPathData {
-    d: string;
-    closed: boolean;
-    hole: boolean;
-}
-
-interface FillGroup {
-    color: string;
-    opacity: number;
-    closed: string[];
-    holes: string[];
-}
-
-interface CachedPolylinePath {
-    pointsRef: Vec3[];
-    signature: number;
-    data: SvgPathData;
-}
-
-const polylinePathCache = new WeakMap<{ points: Vec3[]; closed: boolean }, CachedPolylinePath>();
-
-/**
- * Determine which axes to use for 2D projection based on plane normal.
- * Returns accessor functions for horizontal and vertical SVG coordinates.
- */
-function getProjectionAxes(planeNormal?: Vec3): {
-    getU: (p: Vec3) => number;
-    getV: (p: Vec3) => number;
-    axisNames: string;
-} {
-    if (!planeNormal) {
-        // Default: horizontal plan (looking down Y axis) -> X,Z
-        return {
-            getU: (p) => p[0],
-            getV: (p) => p[2],
-            axisNames: 'XZ'
-        };
-    }
-
-    // Normalize and find dominant axis
-    const absX = Math.abs(planeNormal[0]);
-    const absY = Math.abs(planeNormal[1]);
-    const absZ = Math.abs(planeNormal[2]);
-
-    if (absY > absX && absY > absZ) {
-        // Horizontal plan (normal ~ Y axis) -> looking down Y, use X,Z
-        return {
-            getU: (p) => p[0],
-            getV: (p) => p[2],
-            axisNames: 'XZ'
-        };
-    } else if (absZ > absX) {
-        // Vertical section perpendicular to Z -> looking along Z, use X,Y
-        return {
-            getU: (p) => p[0],
-            getV: (p) => p[1],
-            axisNames: 'XY'
-        };
-    } else {
-        // Vertical section perpendicular to X -> looking along X, use Z,Y
-        return {
-            getU: (p) => p[2],
-            getV: (p) => p[1],
-            axisNames: 'ZY'
-        };
-    }
-}
-
-/**
- * Convert a segment (pair of points) to an SVG path string.
- */
-function segmentToPath(segment: [Vec3, Vec3], planeNormal?: Vec3): string {
-    const [p1, p2] = segment;
-    const axes = getProjectionAxes(planeNormal);
-    const u1 = axes.getU(p1);
-    const v1 = axes.getV(p1);
-    const u2 = axes.getU(p2);
-    const v2 = axes.getV(p2);
-
-    if (!Number.isFinite(u1) || !Number.isFinite(v1) || !Number.isFinite(u2) || !Number.isFinite(v2)) {
-        return '';
-    }
-    return `M${formatNumber(u1)} ${formatNumber(v1)} L${formatNumber(u2)} ${formatNumber(v2)}`;
-}
-
-function getCachedPolylinePath(polyline: { points: Vec3[]; closed: boolean }, planeNormal?: Vec3): SvgPathData | null {
-    if (!polyline.points.length) {
-        return null;
-    }
-
-    const signature = computePointsSignature(polyline.points, polyline.closed, planeNormal);
-    const cached = polylinePathCache.get(polyline);
-    if (cached && cached.pointsRef === polyline.points && cached.signature === signature) {
-        return cached.data;
-    }
-
-    const axes = getProjectionAxes(planeNormal);
-    const commands: string[] = [];
-    polyline.points.forEach((point: Vec3, index: number) => {
-        const prefix = index === 0 ? 'M' : 'L';
-        const u = axes.getU(point);
-        const v = axes.getV(point);
-        commands.push(`${prefix}${formatNumber(u)} ${formatNumber(v)}`);
-    });
-
-    if (commands.length < 2) {
-        return null;
-    }
-
-    let closed = false;
-    let hole = false;
-
-    if (polyline.closed && commands.length > 2) {
-        const area = signedArea(polyline.points, axes);
-        hole = area < 0;
-        closed = true;
-        commands.push('Z');
-    }
-
-    const data: SvgPathData = { d: commands.join(' '), closed, hole };
-    polylinePathCache.set(polyline, { pointsRef: polyline.points, signature, data });
-    return data;
-}
-
-function signedArea(points: Vec3[], axes: { getU: (p: Vec3) => number; getV: (p: Vec3) => number }): number {
-    if (points.length < 3) {
-        return 0;
-    }
-
-    let area = 0;
-    for (let i = 0; i < points.length; i++) {
-        const current = points[i];
-        const next = points[(i + 1) % points.length];
-        const u1 = axes.getU(current);
-        const v1 = axes.getV(current);
-        const u2 = axes.getU(next);
-        const v2 = axes.getV(next);
-        area += u1 * v2 - u2 * v1;
-    }
-    return area * 0.5;
-}
-
-function formatNumber(value: number): string {
-    if (!Number.isFinite(value)) {
-        return '0';
-    }
-    const formatted = value.toFixed(3);
-    return formatted.replace(/\.?0+$/, '');
-}
-
-function buildGeometryTransform(viewMinX: number, viewMaxX: number, viewMinZ: number, viewMaxZ: number): string {
-    const translateX = formatNumber(-viewMinX);
-    const translateY = formatNumber(viewMaxZ);
-    return `matrix(1 0 0 -1 ${translateX} ${translateY})`;
-}
-
-function computePointsSignature(points: readonly Vec3[], closed: boolean, planeNormal?: Vec3): number {
-    const axes = getProjectionAxes(planeNormal);
-    // FNV-1a-inspired hash — compact fixed-size key instead of concatenating all coordinates
-    let hash = 2166136261 ^ (points.length * 16777619) ^ (closed ? 1 : 0);
-    for (let i = 0; i < points.length; i++) {
-        const point = points[i];
-        if (!point) continue;
-        const u = axes.getU(point);
-        const v = axes.getV(point);
-        // Mix in coordinate bits (multiply by large prime, XOR)
-        hash = Math.imul(hash ^ ((u * 1e4) | 0), 16777619);
-        hash = Math.imul(hash ^ ((v * 1e4) | 0), 16777619);
-    }
-    return hash;
-}
+import type {
+    Vec3,
+    SectionLabel,
+    SectionPath,
+    SectionRenderState,
+    TransformInfo,
+    ViewWindow
+} from '@twinfinity/geometry';
+
+export type { SectionLabel, SectionPath, SectionRenderState, TransformInfo, ViewWindow } from '@twinfinity/geometry';
+
+/** Minimal product interface for section fill matching. */
+interface SectionProduct {
+    class?: { is(c: unknown): boolean; type?: string; id?: string };
+    className?: string;
+    propertySets?: Record<string, unknown>;
+    properties?: { data?: Record<string, unknown>; sets?: Record<string, unknown> };
+}
+
+/** Local replacement for PlaneSectionEntry (not available in @twinfinity/geometry). */
+type PlaneSectionEntry<TProduct extends SectionProduct = SectionProduct> = {
+    product: TProduct;
+    segments: [Vec3, Vec3][];
+    polylines: { points: Vec3[]; closed: boolean }[];
+};
+
+/**
+ * Resolve a dotted property path (e.g. "BIP.spacetype") against a product.
+ * Handles both the new T8 API (propertySets → .properties → .value) and
+ * legacy BimIfcObject (properties.sets / properties.data).
+ *
+ * Returns the resolved value, or undefined if not found.
+ */
+export function resolveProductProperty(product: SectionProduct | unknown, path: string): unknown {
+    const p = product as SectionProduct;
+    const parts = path.split('.');
+    if (parts.length < 2) return undefined;
+
+    const [setName, ...propParts] = parts;
+    const propName = propParts.join('.');
+
+    // New T8 API: propertySets['BIP'].properties['spacetype'].value
+    const pset = (p?.propertySets as Record<string, any>)?.[setName];
+    if (pset) {
+        const prop = pset.properties?.[propName];
+        if (prop !== undefined) {
+            return prop?.value !== undefined ? prop.value : prop;
+        }
+    }
+
+    // Legacy: properties.sets['BIP']['spacetype']
+    const legacyPset = (p?.properties?.sets as Record<string, any>)?.[setName];
+    if (legacyPset) {
+        const val = legacyPset[propName];
+        if (val !== undefined) {
+            return val?.value !== undefined ? val.value : val;
+        }
+    }
+
+    // Fallback: properties.data['BIP']['spacetype'] (old printing code path)
+    let value: any = p?.properties?.data;
+    if (value) {
+        for (const part of parts) {
+            value = value?.[part];
+            if (value === undefined) break;
+        }
+        if (value !== undefined) {
+            return value?.value !== undefined ? value.value : value;
+        }
+    }
+
+    return undefined;
+}
+
+/**
+ * Sample the actual rendered color of a product's first mesh.
+ * Uses BimProductMesh.copyColorTo/getColorComponent for accurate colors
+ * (includes overrides, highlights). Falls back to style.surfaceColor/color.
+ */
+const sampleProductColorRgba = (product: unknown): { r: number; g: number; b: number; a: number } | undefined => {
+    /** Duck-typed mesh with optional color-access methods. */
+    interface DuckMesh {
+        copyColorTo?: (out: Uint8Array, offset: number) => void;
+        getColorComponent?: (index: number) => number;
+        style?: { surfaceColor?: readonly number[]; color?: readonly number[] };
+    }
+    const p = product as Record<string, unknown>;
+    const meshes = (p?.meshes ?? p?.productMeshes) as DuckMesh[] | undefined;
+    if (!meshes || !meshes.length) return undefined;
+
+    const rgba = new Uint8Array(4);
+
+    for (const mesh of meshes) {
+        try {
+            // BimProductMesh: read actual rendered color via copyColorTo or getColorComponent
+            if (typeof mesh.copyColorTo === 'function') {
+                mesh.copyColorTo(rgba, 0);
+            } else if (typeof mesh.getColorComponent === 'function') {
+                rgba[0] = mesh.getColorComponent(0); // Red
+                rgba[1] = mesh.getColorComponent(1); // Green
+                rgba[2] = mesh.getColorComponent(2); // Blue
+                rgba[3] = mesh.getColorComponent(3); // Alpha
+            } else {
+                // ModelMesh fallback: read from style
+                const style = mesh.style;
+                const c = style?.surfaceColor ?? style?.color;
+                if (c) return { r: c[0], g: c[1], b: c[2], a: (c[3] ?? 255) / 255 };
+                continue;
+            }
+        } catch {
+            continue;
+        }
+
+        const [r, g, b, a] = rgba;
+        if (a === 0 && r === 0 && g === 0 && b === 0) continue;
+        return { r, g, b, a: a / 255 };
+    }
+
+    return undefined;
+};
+
+/** Base SVG display width in layout units. */
+export const BASE_WIDTH = 240;
+/** Minimum SVG display height in layout units. */
+export const MIN_HEIGHT = 140;
+/** Margin ratio applied around section bounds (fraction of world extent). */
+export const SECTION_MARGIN_RATIO = 0.05;
+/** Maximum zoom factor for viewport clamping. */
+export const MAX_ZOOM_FACTOR = 12;
+/** Multiplicative step for zooming in. */
+export const ZOOM_IN_STEP = 0.8;
+/** Multiplicative step for zooming out. */
+export const ZOOM_OUT_STEP = 1 / ZOOM_IN_STEP;
+const OUTLINE_THICKNESS_SCALE = 0.5;
+
+/** Clamp a number to a min/max range. */
+export function clampValue(value: number, min: number, max: number): number {
+    return Math.min(max, Math.max(min, value));
+}
+
+export interface SectionBuildOptions {
+    /** If true, attach source product metadata to paths/labels for downstream filtering */
+    includeMeta?: boolean;
+    /** When true, create fill paths for closed polygons. When false, create only stroke/outline paths. Defaults to true for backward compatibility. */
+    createFills?: boolean;
+    /** Plane normal vector for determining 2D projection axes. If omitted, defaults to horizontal plan (Y-up). */
+    planeNormal?: Vec3;
+}
+
+/**
+ * Extract product metadata for path/label attribution.
+ * Casts to `any` once here to avoid scattering `as any` across the codebase.
+ * BimIfcObject's runtime shape exposes these fields but the public typings
+ * don't always surface them.
+ */
+function extractProductMeta(product: unknown): {
+    productId: string;
+    ifcClass: string | null;
+    ifcClassId: string | null;
+    properties: unknown;
+} {
+    const p = product as Record<string, any>;
+    return {
+        productId: p?.gid ?? p?.id ?? String(product),
+        ifcClass: p?.class?.type ?? null,
+        ifcClassId: p?.class?.id ?? null,
+        properties: p?.properties?.data ?? p?.properties ?? null
+    };
+}
+
+/** Default fill opacity when a fill rule omits `fillOpacity`. */
+export const DEFAULT_FILL_OPACITY = 0.35;
+
+/**
+ * Fill rule controlling which products get visible fills and at what opacity.
+ * Mirrors the template-level FillRule but kept minimal to avoid circular deps.
+ */
+export interface SectionFillRule {
+    /** IFC class filter. When omitted, matches all products. */
+    class?: string | string[];
+    /** Property-based filter (e.g. { "BIP.spacetype": "ROOM" }). */
+    where?: Record<string, string | number | boolean | Array<string | number>>;
+    /** Fill opacity (0–1). Default: {@link DEFAULT_FILL_OPACITY}. */
+    fillOpacity?: number;
+    /** When true, only apply fill to products whose centroid is inside the clip polygon. @default false */
+    matchClipFilter?: boolean;
+}
+
+export interface BuildSectionStateOptions {
+    viewport?: ViewWindow;
+    strokeWidth?: number;
+    labelFontSize?: number;
+    /**
+     * Fill rules controlling which products get visible fills and at what opacity.
+     * Products matching a fill rule are rendered below non-matching products.
+     * When absent or empty, all products render uniformly (no fill-based reordering).
+     */
+    fills?: SectionFillRule[];
+    includeMeta?: boolean;
+    /** Enable labels. Requires buildLabels callback. */
+    includeLabels?: boolean;
+    /** Callback to build labels for matching products. Required when includeLabels is true. */
+    buildLabels?: (products: any[], fontSize: number) => SectionLabel[];
+    /** Clip polygon in world coordinates (x, z). Used when fill.matchClipFilter is true for spatial filtering. */
+    clipPolygon?: Array<Array<{ x: number; z: number }>>;
+    /** When true, create fill paths for closed polygons. When false, create only stroke/outline paths. Defaults to true for backward compatibility. */
+    createFills?: boolean;
+    /** Plane normal vector for determining 2D projection axes. If omitted, defaults to horizontal plan (Y-up). */
+    planeNormal?: Vec3;
+}
+
+/** Convert plane section polylines to SVG path data with fill colors and stroke styles. */
+export function createSectionSvg(
+    perProduct: PlaneSectionEntry[],
+    viewport?: ViewWindow,
+    strokeWidthHint?: number,
+    labels?: SectionLabel[],
+    options?: SectionBuildOptions
+): SectionRenderState | null {
+    if (!perProduct.length) {
+        return null;
+    }
+
+    const polylines = perProduct.flatMap((entry) => entry.polylines);
+    const hasSegments = perProduct.some((entry) => entry.segments && entry.segments.length > 0);
+
+    if (!polylines.length && !hasSegments) {
+        return null;
+    }
+
+    const planeNormal = options?.planeNormal;
+    const axes = getProjectionAxes(planeNormal);
+
+    let viewMinX: number;
+    let viewMaxX: number;
+    let viewMinZ: number;
+    let viewMaxZ: number;
+
+    if (viewport) {
+        viewMinX = viewport.viewMinX;
+        viewMaxX = viewport.viewMaxX;
+        viewMinZ = viewport.viewMinZ;
+        viewMaxZ = viewport.viewMaxZ;
+    } else {
+        let minU = Number.POSITIVE_INFINITY;
+        let maxU = Number.NEGATIVE_INFINITY;
+        let minV = Number.POSITIVE_INFINITY;
+        let maxV = Number.NEGATIVE_INFINITY;
+
+        polylines.forEach((polyline: { points: Vec3[]; closed: boolean }) => {
+            polyline.points.forEach((point: Vec3) => {
+                if (!point) {
+                    return;
+                }
+                const u = axes.getU(point);
+                const v = axes.getV(point);
+                if (!Number.isFinite(u) || !Number.isFinite(v)) {
+                    return;
+                }
+                if (u < minU) minU = u;
+                if (u > maxU) maxU = u;
+                if (v < minV) minV = v;
+                if (v > maxV) maxV = v;
+            });
+        });
+
+        // Also include segments in bounding box calculation
+        perProduct.forEach((entry) => {
+            if (entry.segments && entry.segments.length) {
+                entry.segments.forEach((segment) => {
+                    const [p1, p2] = segment;
+                    const u1 = axes.getU(p1);
+                    const v1 = axes.getV(p1);
+                    const u2 = axes.getU(p2);
+                    const v2 = axes.getV(p2);
+                    if (Number.isFinite(u1) && Number.isFinite(v1)) {
+                        if (u1 < minU) minU = u1;
+                        if (u1 > maxU) maxU = u1;
+                        if (v1 < minV) minV = v1;
+                        if (v1 > maxV) maxV = v1;
+                    }
+                    if (Number.isFinite(u2) && Number.isFinite(v2)) {
+                        if (u2 < minU) minU = u2;
+                        if (u2 > maxU) maxU = u2;
+                        if (v2 < minV) minV = v2;
+                        if (v2 > maxV) maxV = v2;
+                    }
+                });
+            }
+        });
+
+        if (!Number.isFinite(minU) || !Number.isFinite(maxU) || !Number.isFinite(minV) || !Number.isFinite(maxV)) {
+            return null;
+        }
+
+        if (maxU - minU < 1e-3) {
+            minU -= 0.5;
+            maxU += 0.5;
+        }
+        if (maxV - minV < 1e-3) {
+            minV -= 0.5;
+            maxV += 0.5;
+        }
+
+        const worldWidth = maxU - minU;
+        const worldHeight = maxV - minV;
+        const marginU = Math.max(worldWidth * SECTION_MARGIN_RATIO, 0.5);
+        const marginV = Math.max(worldHeight * SECTION_MARGIN_RATIO, 0.5);
+
+        viewMinX = minU - marginU;
+        viewMaxX = maxU + marginU;
+        viewMinZ = minV - marginV;
+        viewMaxZ = maxV + marginV;
+    }
+
+    const viewWidth = viewMaxX - viewMinX;
+    const viewHeight = viewMaxZ - viewMinZ;
+
+    if (!Number.isFinite(viewWidth) || !Number.isFinite(viewHeight) || viewWidth <= 1e-6 || viewHeight <= 1e-6) {
+        return null;
+    }
+
+    const autoStrokeBase = Math.max(Math.min(viewWidth, viewHeight) * 0.008, 0.08);
+    const autoStroke = Math.max(autoStrokeBase * OUTLINE_THICKNESS_SCALE, 0.02);
+    const strokeWidth = Math.max(strokeWidthHint ?? autoStroke, 0.02);
+    const geometryTransform = buildGeometryTransform(viewMinX, viewMaxX, viewMinZ, viewMaxZ);
+
+    const includeMeta = !!options?.includeMeta;
+    const createFills = options?.createFills !== false; // Default to true for backward compatibility
+
+    const allPaths: SectionPath[] = [];
+    if (includeMeta) {
+        perProduct.forEach((entry, idx) => {
+            // Skip entries with neither polylines nor segments
+            if (!entry.polylines.length && (!entry.segments || !entry.segments.length)) {
+                return;
+            }
+            const colorInfo = sampleProductColorRgba(entry.product);
+            const fillColor = colorInfo ? `rgb(${colorInfo.r},${colorInfo.g},${colorInfo.b})` : '#ffffff';
+            const fillOpacity = colorInfo ? clampValue(colorInfo.a, 0, 1) : 1;
+            const meta = extractProductMeta(entry.product);
+
+            const closedSubpaths: string[] = [];
+            const holeSubpaths: string[] = [];
+            const openSubpaths: string[] = [];
+
+            entry.polylines.forEach((polyline) => {
+                const pathData = getCachedPolylinePath(polyline, planeNormal);
+                if (!pathData) {
+                    return;
+                }
+                if (pathData.closed) {
+                    if (pathData.hole) {
+                        holeSubpaths.push(pathData.d);
+                    } else {
+                        closedSubpaths.push(pathData.d);
+                    }
+                } else {
+                    openSubpaths.push(pathData.d);
+                }
+            });
+
+            // Only create fill paths if createFills is true
+            if (createFills && (closedSubpaths.length || holeSubpaths.length)) {
+                const fillSubpaths = closedSubpaths.length ? closedSubpaths.concat(holeSubpaths) : holeSubpaths;
+                allPaths.push({
+                    key: `fill-${idx}`,
+                    d: fillSubpaths.join(' '),
+                    fill: fillColor,
+                    fillOpacity: clampValue(fillOpacity, 0, 1),
+                    stroke: '#1f2937',
+                    strokeWidth,
+                    fillRule: 'evenodd',
+                    meta: meta ? { ...meta, isFill: true } : undefined
+                });
+            }
+
+            if (openSubpaths.length) {
+                allPaths.push({
+                    key: `outline-${idx}`,
+                    d: openSubpaths.join(' '),
+                    fill: 'none',
+                    fillOpacity: 1,
+                    stroke: '#1f2937',
+                    strokeWidth,
+                    meta: meta ? { ...meta, isOutline: true } : undefined
+                });
+            }
+
+            // Render segments (cut edges) as strokes
+            if (entry.segments && entry.segments.length) {
+                const segmentPaths: string[] = [];
+                for (const segment of entry.segments) {
+                    const path = segmentToPath(segment, planeNormal);
+                    if (path) segmentPaths.push(path);
+                }
+                if (segmentPaths.length) {
+                    allPaths.push({
+                        key: `segments-${idx}`,
+                        d: segmentPaths.join(' '),
+                        fill: 'none',
+                        fillOpacity: 1,
+                        stroke: '#1f2937',
+                        strokeWidth,
+                        meta: meta ? { ...meta, isSegment: true } : undefined
+                    });
+                }
+            }
+        });
+    } else {
+        const fillGroups = new Map<string, FillGroup>();
+        const openSubpaths: string[] = [];
+        const allSegmentPaths: string[] = [];
+
+        perProduct.forEach((entry) => {
+            // Process segments first (always render, even without polylines)
+            if (entry.segments && entry.segments.length) {
+                for (const segment of entry.segments) {
+                    const path = segmentToPath(segment, planeNormal);
+                    if (path) allSegmentPaths.push(path);
+                }
+            }
+
+            if (!entry.polylines.length) {
+                return;
+            }
+
+            const colorInfo = sampleProductColorRgba(entry.product);
+            const fillColor = colorInfo ? `rgb(${colorInfo.r},${colorInfo.g},${colorInfo.b})` : '#ffffff';
+            const fillOpacity = colorInfo ? clampValue(colorInfo.a, 0, 1) : 1;
+            const groupKey = `${fillColor}|${Math.round(fillOpacity * 1000)}`;
+            let group = fillGroups.get(groupKey);
+            if (!group) {
+                group = {
+                    color: fillColor,
+                    opacity: fillOpacity,
+                    closed: [],
+                    holes: []
+                };
+                fillGroups.set(groupKey, group);
+            }
+
+            entry.polylines.forEach((polyline) => {
+                const pathData = getCachedPolylinePath(polyline, planeNormal);
+                if (!pathData) {
+                    return;
+                }
+                if (pathData.closed) {
+                    if (pathData.hole) {
+                        group!.holes.push(pathData.d);
+                    } else {
+                        group!.closed.push(pathData.d);
+                    }
+                    return;
+                }
+                openSubpaths.push(pathData.d);
+            });
+        });
+
+        let groupIndex = 0;
+        fillGroups.forEach((group) => {
+            const fillSubpaths = group.closed.length ? group.closed.concat(group.holes) : group.holes;
+            if (!fillSubpaths.length) {
+                return;
+            }
+            allPaths.push({
+                key: `fill-${groupIndex++}`,
+                d: fillSubpaths.join(' '),
+                fill: group.color,
+                fillOpacity: clampValue(group.opacity, 0, 1),
+                stroke: '#1f2937',
+                strokeWidth,
+                fillRule: 'evenodd'
+            });
+        });
+
+        if (openSubpaths.length) {
+            allPaths.push({
+                key: 'outlines',
+                d: openSubpaths.join(' '),
+                fill: 'none',
+                fillOpacity: 1,
+                stroke: '#1f2937',
+                strokeWidth
+            });
+        }
+
+        // Render all segments (collected above in forEach loop)
+        if (allSegmentPaths.length) {
+            allPaths.push({
+                key: 'segments',
+                d: allSegmentPaths.join(' '),
+                fill: 'none',
+                fillOpacity: 1,
+                stroke: '#1f2937',
+                strokeWidth
+            });
+        }
+    }
+
+    if (!allPaths.length) {
+        return null;
+    }
+
+    const displayWidth = BASE_WIDTH;
+    const displayHeight = Math.max(MIN_HEIGHT, (viewHeight / viewWidth) * BASE_WIDTH);
+
+    return {
+        paths: allPaths,
+        transform: {
+            viewMinX,
+            viewMaxX,
+            viewMinZ,
+            viewMaxZ,
+            viewWidth,
+            viewHeight,
+            displayWidth,
+            displayHeight
+        },
+        strokeWidth,
+        geometryTransform,
+        labels: labels?.length
+            ? labels
+                  .filter((label) => {
+                      if (!Number.isFinite(label.x) || !Number.isFinite(label.z)) {
+                          return false;
+                      }
+                      return label.x >= viewMinX && label.x <= viewMaxX && label.z >= viewMinZ && label.z <= viewMaxZ;
+                  })
+                  .map((label) => ({
+                      key: label.key,
+                      text: label.text,
+                      x: label.x,
+                      y: label.y,
+                      z: label.z,
+                      fontSize: label.fontSize,
+                      meta: includeMeta ? (label.meta ?? {}) : undefined
+                  }))
+            : []
+    };
+}
+
+/**
+ * Build a complete SectionRenderState from plane section entries, with optional
+ * fill-rule-based separation, ordering, and label generation.
+ *
+ * When `fills` rules are provided, entries matching a fill rule are rendered
+ * below non-matching entries, with their fill opacity set by the matching rule.
+ */
+export function buildSectionStateForEntries(
+    perProduct: PlaneSectionEntry[],
+    options: BuildSectionStateOptions
+): (SectionRenderState & { rawPaths?: SectionPath[]; rawLabels?: SectionLabel[] }) | null {
+    if (!perProduct.length) {
+        return null;
+    }
+
+    const fills = options.fills;
+    const includeMeta = !!options?.includeMeta;
+    const includeLabels = options?.includeLabels ?? false;
+    const viewport = options?.viewport;
+    const strokeWidth = options?.strokeWidth;
+    const labelFontSize = includeLabels && typeof options?.labelFontSize === 'number' ? options.labelFontSize : null;
+    const buildLabels = options?.buildLabels;
+
+    // Point-in-polygon test (ray casting algorithm)
+    const pointInPolygon = (polygon: Array<{ x: number; z: number }>, x: number, z: number): boolean => {
+        let inside = false;
+        for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+            const xi = polygon[i].x;
+            const zi = polygon[i].z;
+            const xj = polygon[j].x;
+            const zj = polygon[j].z;
+            const intersect = zi > z !== zj > z && x < ((xj - xi) * (z - zi)) / (zj - zi) + xi;
+            if (intersect) inside = !inside;
+        }
+        return inside;
+    };
+
+    // Calculate centroid from entry's polylines
+    const getCentroid = (entry: PlaneSectionEntry): { x: number; z: number } | null => {
+        const polylines = entry.polylines;
+        if (!polylines.length) return null;
+        let sumX = 0;
+        let sumZ = 0;
+        let count = 0;
+        for (const polyline of polylines) {
+            for (const point of polyline.points) {
+                sumX += point[0];
+                sumZ += point[2];
+                count++;
+            }
+        }
+        if (count === 0) return null;
+        return { x: sumX / count, z: sumZ / count };
+    };
+
+    // Spatial matcher for clip filter - checks if product centroid is inside clip polygon
+    const isInsideClipPolygon = (entry: PlaneSectionEntry): boolean => {
+        if (!options?.clipPolygon?.length) return true;
+        const centroid = getCentroid(entry);
+        if (!centroid) return false;
+        // Check if centroid is inside any of the clip polygons
+        return options.clipPolygon.some((polygon) => pointInPolygon(polygon, centroid.x, centroid.z));
+    };
+
+    // Match an entry against fill rules. Returns the first matching rule, or undefined.
+    const matchFillRule = (entry: PlaneSectionEntry): SectionFillRule | undefined => {
+        if (!fills?.length) return undefined;
+        const product = entry.product;
+        for (const rule of fills) {
+            // If rule requires clip filter match, check if product centroid is inside clip polygon
+            if (rule.matchClipFilter && !isInsideClipPolygon(entry)) {
+                continue;
+            }
+
+            // Check class match
+            let classMatches: boolean;
+            if (rule.class) {
+                const classes = Array.isArray(rule.class) ? rule.class : [rule.class];
+                const cls = product.class;
+                classMatches = classes.some((c) => {
+                    if (cls?.is) return cls.is(c as string);
+                    const pName = (product.className ?? '').toLowerCase();
+                    return pName === (c as string).toLowerCase() || pName === `ifc${(c as string).toLowerCase()}`;
+                });
+                if (!classMatches) continue;
+            }
+
+            // Check where condition (property-based filter)
+            if (rule.where && Object.keys(rule.where).length > 0) {
+                let whereMatches = true;
+                for (const [path, expected] of Object.entries(rule.where)) {
+                    const actualValue = resolveProductProperty(product, path);
+                    if (actualValue === undefined) {
+                        whereMatches = false;
+                        break;
+                    }
+
+                    const normalize = (v: unknown): unknown => (typeof v === 'string' ? v.toLowerCase().trim() : v);
+
+                    if (Array.isArray(expected)) {
+                        if (!expected.some((exp) => normalize(exp) === normalize(actualValue))) {
+                            whereMatches = false;
+                            break;
+                        }
+                    } else {
+                        if (normalize(actualValue) !== normalize(expected)) {
+                            whereMatches = false;
+                            break;
+                        }
+                    }
+                }
+                if (!whereMatches) continue;
+            }
+
+            return rule;
+        }
+        return undefined;
+    };
+
+    const hasFills = !!fills?.length;
+
+    // Split entries by fill rule match
+    const fillEntries: PlaneSectionEntry[] = [];
+    const fillOpacities: number[] = []; // parallel to fillEntries
+    const nonFillEntries: PlaneSectionEntry[] = [];
+
+    for (const entry of perProduct) {
+        const rule = hasFills ? matchFillRule(entry) : undefined;
+        if (rule) {
+            const opacity = rule.fillOpacity ?? DEFAULT_FILL_OPACITY;
+            // Skip entries with zero opacity - don't render them at all
+            if (opacity > 0) {
+                fillEntries.push(entry);
+                fillOpacities.push(opacity);
+            }
+        } else {
+            nonFillEntries.push(entry);
+        }
+    }
+
+    // Build labels from fill-matched entries (e.g. spaces)
+    const fillLabels =
+        includeLabels && fillEntries.length && labelFontSize !== null && buildLabels
+            ? (buildLabels(
+                  fillEntries.map((entry) => entry.product),
+                  labelFontSize
+              ) as SectionLabel[])
+            : undefined;
+
+    // When fill rules are present, render fill and non-fill groups separately
+    // so we can adjust opacity and control ordering.
+    // When no fill rules, render everything in one pass (unchanged behavior).
+    if (hasFills && (fillEntries.length > 0 || nonFillEntries.length > 0)) {
+        const nonFillState =
+            nonFillEntries.length > 0
+                ? createSectionSvg(nonFillEntries, viewport, strokeWidth, undefined, {
+                      includeMeta,
+                      planeNormal: options.planeNormal
+                  })
+                : null;
+        const fillState =
+            fillEntries.length > 0
+                ? createSectionSvg(fillEntries, viewport, strokeWidth, includeLabels ? fillLabels : undefined, {
+                      includeMeta,
+                      planeNormal: options.planeNormal
+                  })
+                : null;
+
+        const baseState = nonFillState ?? fillState ?? null;
+        if (!baseState) return null;
+
+        // Adjust fill opacity per-entry. When includeMeta is true, each entry has
+        // its own path, so we can apply per-entry opacity. When false, paths are
+        // grouped by color — apply the minimum matching opacity.
+        const adjustedFillPaths =
+            fillState?.paths.map((path, idx) => {
+                // When fill rules match, use the rule opacity directly (don't multiply by material alpha).
+                // Material alpha was useful for auto-coloring, but fill rules should have full control.
+                const ruleOpacity = idx < fillOpacities.length ? fillOpacities[idx] : (fills![0]?.fillOpacity ?? 0.35);
+                const finalOpacity = clampValue(ruleOpacity, 0, 1);
+                return {
+                    ...path,
+                    fillOpacity: finalOpacity
+                };
+            }) ?? [];
+
+        const nonFillPaths = nonFillState?.paths ?? [];
+        // Fill-matched entries always render below non-fill entries
+        const mergedPaths = [...adjustedFillPaths, ...nonFillPaths];
+
+        const merged: SectionRenderState & { rawPaths?: SectionPath[]; rawLabels?: SectionLabel[] } = {
+            ...baseState,
+            paths: mergedPaths,
+            labels: includeLabels ? (fillState?.labels ?? fillLabels ?? []) : []
+        };
+
+        return merged;
+    }
+
+    // No fill rules — create paths with fills for highlight support, but set opacity to 0
+    const state = createSectionSvg(perProduct, viewport, strokeWidth, includeLabels ? fillLabels : undefined, {
+        includeMeta,
+        createFills: true,
+        planeNormal: options.planeNormal
+    });
+    if (!state) return null;
+
+    // Set all fill opacities to 0 when no fill rules exist (but keep paths for highlight support)
+    const pathsWithZeroFillOpacity = state.paths.map((path) => ({
+        ...path,
+        fillOpacity: 0
+    }));
+
+    return {
+        ...state,
+        paths: pathsWithZeroFillOpacity,
+        labels: includeLabels ? (state.labels ?? []) : []
+    };
+}
+
+/** Extract the viewport bounding box from a TransformInfo. */
+export function extractViewWindow(transform: TransformInfo): ViewWindow {
+    return {
+        viewMinX: transform.viewMinX,
+        viewMaxX: transform.viewMaxX,
+        viewMinZ: transform.viewMinZ,
+        viewMaxZ: transform.viewMaxZ
+    };
+}
+
+/** Compare two viewport windows for equality within a tolerance. */
+export function windowsEqual(a: ViewWindow, b: ViewWindow, epsilon = 1e-4): boolean {
+    return (
+        Math.abs(a.viewMinX - b.viewMinX) <= epsilon &&
+        Math.abs(a.viewMaxX - b.viewMaxX) <= epsilon &&
+        Math.abs(a.viewMinZ - b.viewMinZ) <= epsilon &&
+        Math.abs(a.viewMaxZ - b.viewMaxZ) <= epsilon
+    );
+}
+
+/** Constrain a viewport window within base bounds, preserving aspect ratio. */
+export function clampViewWindow(base: TransformInfo, candidate: ViewWindow): ViewWindow {
+    const baseWidth = base.viewWidth;
+    const baseHeight = base.viewHeight;
+    const aspect = baseWidth / baseHeight;
+
+    let width = candidate.viewMaxX - candidate.viewMinX;
+
+    if (!Number.isFinite(width) || width <= 1e-6) {
+        width = baseWidth;
+    }
+    width = clampValue(width, baseWidth / MAX_ZOOM_FACTOR, baseWidth);
+    const height = width / aspect;
+
+    let centerX = (candidate.viewMinX + candidate.viewMaxX) * 0.5;
+    if (!Number.isFinite(centerX)) {
+        centerX = (base.viewMinX + base.viewMaxX) * 0.5;
+    }
+
+    let centerZ = (candidate.viewMinZ + candidate.viewMaxZ) * 0.5;
+    if (!Number.isFinite(centerZ)) {
+        centerZ = (base.viewMinZ + base.viewMaxZ) * 0.5;
+    }
+
+    let minX = centerX - width * 0.5;
+    let maxX = minX + width;
+    if (minX < base.viewMinX) {
+        minX = base.viewMinX;
+        maxX = minX + width;
+    }
+    if (maxX > base.viewMaxX) {
+        maxX = base.viewMaxX;
+        minX = maxX - width;
+    }
+
+    let minZ = centerZ - height * 0.5;
+    let maxZ = minZ + height;
+    if (minZ < base.viewMinZ) {
+        minZ = base.viewMinZ;
+        maxZ = minZ + height;
+    }
+    if (maxZ > base.viewMaxZ) {
+        maxZ = base.viewMaxZ;
+        minZ = maxZ - height;
+    }
+
+    return {
+        viewMinX: minX,
+        viewMaxX: maxX,
+        viewMinZ: minZ,
+        viewMaxZ: maxZ
+    };
+}
+
+/** Adjust stroke width proportionally to zoom level. */
+export function strokeWidthForWindow(baseStroke: number, baseTransform: TransformInfo, window: ViewWindow): number {
+    const baseWidth = baseTransform.viewWidth;
+    const currentWidth = window.viewMaxX - window.viewMinX;
+    if (!Number.isFinite(baseWidth) || baseWidth <= 1e-6 || !Number.isFinite(currentWidth) || currentWidth <= 1e-6) {
+        return baseStroke;
+    }
+    const ratio = clampValue(currentWidth / baseWidth, 1 / MAX_ZOOM_FACTOR, 1);
+    const scaled = baseStroke * ratio;
+    return Math.max(scaled, baseStroke / (MAX_ZOOM_FACTOR + 1));
+}
+
+interface SvgPathData {
+    d: string;
+    closed: boolean;
+    hole: boolean;
+}
+
+interface FillGroup {
+    color: string;
+    opacity: number;
+    closed: string[];
+    holes: string[];
+}
+
+interface CachedPolylinePath {
+    pointsRef: Vec3[];
+    signature: number;
+    data: SvgPathData;
+}
+
+const polylinePathCache = new WeakMap<{ points: Vec3[]; closed: boolean }, CachedPolylinePath>();
+
+/**
+ * Determine which axes to use for 2D projection based on plane normal.
+ * Returns accessor functions for horizontal and vertical SVG coordinates.
+ */
+function getProjectionAxes(planeNormal?: Vec3): {
+    getU: (p: Vec3) => number;
+    getV: (p: Vec3) => number;
+    axisNames: string;
+} {
+    if (!planeNormal) {
+        // Default: horizontal plan (looking down Y axis) -> X,Z
+        return {
+            getU: (p) => p[0],
+            getV: (p) => p[2],
+            axisNames: 'XZ'
+        };
+    }
+
+    // Normalize and find dominant axis
+    const absX = Math.abs(planeNormal[0]);
+    const absY = Math.abs(planeNormal[1]);
+    const absZ = Math.abs(planeNormal[2]);
+
+    if (absY > absX && absY > absZ) {
+        // Horizontal plan (normal ~ Y axis) -> looking down Y, use X,Z
+        return {
+            getU: (p) => p[0],
+            getV: (p) => p[2],
+            axisNames: 'XZ'
+        };
+    } else if (absZ > absX) {
+        // Vertical section perpendicular to Z -> looking along Z, use X,Y
+        return {
+            getU: (p) => p[0],
+            getV: (p) => p[1],
+            axisNames: 'XY'
+        };
+    } else {
+        // Vertical section perpendicular to X -> looking along X, use Z,Y
+        return {
+            getU: (p) => p[2],
+            getV: (p) => p[1],
+            axisNames: 'ZY'
+        };
+    }
+}
+
+/**
+ * Convert a segment (pair of points) to an SVG path string.
+ */
+function segmentToPath(segment: [Vec3, Vec3], planeNormal?: Vec3): string {
+    const [p1, p2] = segment;
+    const axes = getProjectionAxes(planeNormal);
+    const u1 = axes.getU(p1);
+    const v1 = axes.getV(p1);
+    const u2 = axes.getU(p2);
+    const v2 = axes.getV(p2);
+
+    if (!Number.isFinite(u1) || !Number.isFinite(v1) || !Number.isFinite(u2) || !Number.isFinite(v2)) {
+        return '';
+    }
+    return `M${formatNumber(u1)} ${formatNumber(v1)} L${formatNumber(u2)} ${formatNumber(v2)}`;
+}
+
+function getCachedPolylinePath(polyline: { points: Vec3[]; closed: boolean }, planeNormal?: Vec3): SvgPathData | null {
+    if (!polyline.points.length) {
+        return null;
+    }
+
+    const signature = computePointsSignature(polyline.points, polyline.closed, planeNormal);
+    const cached = polylinePathCache.get(polyline);
+    if (cached && cached.pointsRef === polyline.points && cached.signature === signature) {
+        return cached.data;
+    }
+
+    const axes = getProjectionAxes(planeNormal);
+    const commands: string[] = [];
+    polyline.points.forEach((point: Vec3, index: number) => {
+        const prefix = index === 0 ? 'M' : 'L';
+        const u = axes.getU(point);
+        const v = axes.getV(point);
+        commands.push(`${prefix}${formatNumber(u)} ${formatNumber(v)}`);
+    });
+
+    if (commands.length < 2) {
+        return null;
+    }
+
+    let closed = false;
+    let hole = false;
+
+    if (polyline.closed && commands.length > 2) {
+        const area = signedArea(polyline.points, axes);
+        hole = area < 0;
+        closed = true;
+        commands.push('Z');
+    }
+
+    const data: SvgPathData = { d: commands.join(' '), closed, hole };
+    polylinePathCache.set(polyline, { pointsRef: polyline.points, signature, data });
+    return data;
+}
+
+function signedArea(points: Vec3[], axes: { getU: (p: Vec3) => number; getV: (p: Vec3) => number }): number {
+    if (points.length < 3) {
+        return 0;
+    }
+
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        const u1 = axes.getU(current);
+        const v1 = axes.getV(current);
+        const u2 = axes.getU(next);
+        const v2 = axes.getV(next);
+        area += u1 * v2 - u2 * v1;
+    }
+    return area * 0.5;
+}
+
+function formatNumber(value: number): string {
+    if (!Number.isFinite(value)) {
+        return '0';
+    }
+    const formatted = value.toFixed(3);
+    return formatted.replace(/\.?0+$/, '');
+}
+
+function buildGeometryTransform(viewMinX: number, viewMaxX: number, viewMinZ: number, viewMaxZ: number): string {
+    const translateX = formatNumber(-viewMinX);
+    const translateY = formatNumber(viewMaxZ);
+    return `matrix(1 0 0 -1 ${translateX} ${translateY})`;
+}
+
+function computePointsSignature(points: readonly Vec3[], closed: boolean, planeNormal?: Vec3): number {
+    const axes = getProjectionAxes(planeNormal);
+    // FNV-1a-inspired hash — compact fixed-size key instead of concatenating all coordinates
+    let hash = 2166136261 ^ (points.length * 16777619) ^ (closed ? 1 : 0);
+    for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        if (!point) continue;
+        const u = axes.getU(point);
+        const v = axes.getV(point);
+        // Mix in coordinate bits (multiply by large prime, XOR)
+        hash = Math.imul(hash ^ ((u * 1e4) | 0), 16777619);
+        hash = Math.imul(hash ^ ((v * 1e4) | 0), 16777619);
+    }
+    return hash;
+}