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

package/src/layout/itemBuilders.ts

@@ -93,6 +93,22 @@ const getBBoxCenter = (product: unknown): { x: number | null; z: number | null }
     return { x: null, z: null };
 };
 
+/**
+ * Read the plan-projection X/Z of a polyline point, tolerating both shapes the
+ * section pipeline emits: `Vec3` arrays `[x, y, z]` (from
+ * `computePlaneSectionsForProducts`) and `{ x, z }` objects. Coords are `null`
+ * when the point is neither / non-finite. Shared by every consumer so the dual
+ * contract is handled in exactly one place.
+ */
+export const readXZ = (pt: unknown): { x: number | null; z: number | null } => {
+    const rawX = Array.isArray(pt) ? pt[0] : getProp(pt, 'x');
+    const rawZ = Array.isArray(pt) ? pt[2] : getProp(pt, 'z');
+    return {
+        x: Number.isFinite(rawX) ? (rawX as number) : null,
+        z: Number.isFinite(rawZ) ? (rawZ as number) : null
+    };
+};
+
 export const computePolylinesCenter = (entry: unknown): { x: number | null; z: number | null } => {
     try {
         const polylines = getProp(entry, 'polylines');
@@ -106,11 +122,10 @@ export const computePolylinesCenter = (entry: unknown): { x: number | null; z: n
             const points = getProp(polyline, 'points');
             if (!Array.isArray(points)) continue;
             for (const pt of points) {
-                const px = getProp(pt, 'x');
-                const pz = getProp(pt, 'z');
-                if (Number.isFinite(px) && Number.isFinite(pz)) {
-                    sumX += px as number;
-                    sumZ += pz as number;
+                const { x: px, z: pz } = readXZ(pt);
+                if (px !== null && pz !== null) {
+                    sumX += px;
+                    sumZ += pz;
                     count++;
                 }
             }

package/src/layout/labelsRender.ts

@@ -1,7 +1,15 @@
 import { LabelsElement, LayoutData } from './types';
-import { matchesV2Filter } from './filters';
+import { matchesFilter } from './filters';
 import { pointInPolygon } from './clipUtils';
-import { getPathValue, resolvePath, escapeAttr, escapeText } from './renderUtils';
+import {
+    getPathValue,
+    resolvePath,
+    escapeAttr,
+    escapeText,
+    formatNumber,
+    splitPlaceholder,
+    applyPlaceholderFilter
+} from './renderUtils';
 
 import { isRecord, getProp } from './typeGuards';
 
@@ -60,41 +68,22 @@ export const renderLabels = (
         }
         // Filter by class + where
         let filteredItems =
-            dl.class || dl.where ? items.filter((item) => matchesV2Filter(item, dl.class, dl.where)) : items;
-
-        console.log(`[Labels ${dl.id}] Total items:`, items.length, 'After class+where filter:', filteredItems.length);
+            dl.class || dl.where ? items.filter((item) => matchesFilter(item, dl.class, dl.where)) : items;
 
         // If matchClipFilter is true, filter by spatial position inside clip polygon
         if (dl.matchClipFilter && viewportClipPolygonsWorld[dl.viewport]?.length) {
-            const clipPolygons = viewportClipPolygonsWorld[dl.viewport];
-            console.log(`[Labels ${dl.id}] Applying matchClipFilter (spatial) with ${clipPolygons.length} polygons`);
-            const beforeClipFilter = filteredItems.length;
+            // pointInPolygon expects y — world polys are {x, z}; map ONCE, not per item.
+            const polys2D = viewportClipPolygonsWorld[dl.viewport].map((poly) => poly.map((p) => ({ x: p.x, y: p.z })));
             filteredItems = filteredItems.filter((item) => {
                 const ix = getProp(item, 'x');
                 const iz = getProp(item, 'z');
                 if (!Number.isFinite(ix) || !Number.isFinite(iz)) return false;
-                return clipPolygons.some((poly) => {
-                    // pointInPolygon expects y coordinate, but we use z for world space
-                    const polyWith2D = poly.map((p) => ({ x: p.x, y: p.z }));
-                    return pointInPolygon(polyWith2D, ix as number, iz as number);
-                });
+                return polys2D.some((poly) => pointInPolygon(poly, ix as number, iz as number));
             });
-            console.log(
-                `[Labels ${dl.id}] After matchClipFilter (spatial):`,
-                filteredItems.length,
-                '(was:',
-                beforeClipFilter,
-                ')'
-            );
-
-            // Debug: log first few items to see their properties
-            if (filteredItems.length === 0 && beforeClipFilter > 0) {
-                console.log('[Labels] Sample item that was filtered out:', items[0]);
-            }
         }
 
         if (!filteredItems.length) {
-            console.log(`[Labels ${dl.id}] No items left after filtering, skipping.`);
+            warnings.push(`Labels '${dl.id}' matched 0 of ${items.length} items after filtering.`);
             continue;
         }
         const styleName = dl.textStyle;
@@ -103,12 +92,10 @@ export const renderLabels = (
             warnings.push(`Labels '${dl.id}' missing textStyle '${styleName ?? '(none)'}'.`);
             continue;
         }
-        const anchor = dl.align === 'center' ? 'middle' : dl.align === 'right' ? 'end' : 'start';
+        // Schema default is center — labels sit on item centroids.
+        const anchor = dl.align === 'left' ? 'start' : dl.align === 'right' ? 'end' : 'middle';
         const t = vpInfo.transform;
 
-        let renderedCount = 0;
-        let spatiallyFilteredCount = 0;
-
         filteredItems.forEach((item) => {
             // Hardcoded x/z for BIM floor plane convention
             const xVal = getProp(item, 'x');
@@ -128,18 +115,18 @@ export const renderLabels = (
                     pointInPolygon(poly, viewX, viewY)
                 );
                 if (!inside) {
-                    spatiallyFilteredCount++;
                     return;
                 }
             }
 
-            renderedCount++;
-
             const text = escapeText(
                 dl.text && typeof dl.text === 'string'
-                    ? dl.text.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_m, path) => {
+                    ? dl.text.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_m, expr) => {
+                          const { path, filter } = splitPlaceholder(expr);
                           const val = resolvePath(item, path) ?? getPathValue(dataWithViewport, path);
-                          return val === undefined || val === null || typeof val === 'object' ? '' : String(val);
+                          return val === undefined || val === null || typeof val === 'object'
+                              ? ''
+                              : String(applyPlaceholderFilter(val, filter));
                       })
                     : ''
             );
@@ -152,7 +139,7 @@ export const renderLabels = (
             const lineHeightMm = getProp(style, 'lineHeightMm');
 
             parts.push(
-                `<text x="${xMm}" y="${yMm}" font-family="${escapeAttr(String(fontFamily))}" font-size="${fontSizeMm}"` +
+                `<text x="${formatNumber(xMm)}" y="${formatNumber(yMm)}" font-family="${escapeAttr(String(fontFamily))}" font-size="${fontSizeMm}"` +
                     (fontWeight ? ` font-weight="${escapeAttr(String(fontWeight))}"` : '') +
                     (color ? ` fill="${escapeAttr(String(color))}"` : '') +
                     (letterSpacingMm !== undefined ? ` letter-spacing="${letterSpacingMm}"` : '') +
@@ -160,10 +147,6 @@ export const renderLabels = (
                     ` text-anchor="${anchor}">${text}</text>`
             );
         });
-
-        console.log(
-            `[Labels ${dl.id}] Rendered ${renderedCount} labels. Spatially filtered out: ${spatiallyFilteredCount}`
-        );
     }
 
     return parts;

package/src/layout/legendRender.ts

@@ -14,8 +14,8 @@ import {
     parseLegendColor,
     formatLegendValue
 } from './legendUtils';
-import { resolvePath } from './renderUtils';
-import { matchesV2Filter } from './filters';
+import { resolvePath, escapeText, escapeAttr } from './renderUtils';
+import { matchesFilter } from './filters';
 import { pointInPolygon } from './clipUtils';
 
 /**
@@ -80,43 +80,52 @@ import { isRecord, getProp } from './typeGuards';
 export const applyLegendFilter = (
     legendData: unknown[],
     legend: LegendElement,
-    viewports: unknown[],
-    viewportClipPolygonsLocal: Record<string, Array<Array<{ x: number; y: number }>>>,
-    viewportRenderInfo: Record<string, { transform?: unknown }>
+    viewportClipPolygonsWorld: Record<string, Array<Array<{ x: number; z: number }>>>
 ): unknown[] => {
     // Filter by class + where
     let rows = Array.isArray(legendData)
-        ? legendData.filter((row) => matchesV2Filter(row, legend.class, legend.where))
+        ? legendData.filter((row) => matchesFilter(row, legend.class, legend.where))
         : [];
     if (!rows.length) return rows;
 
+    // clipToViewport filters in WORLD space (same convention as labels and
+    // clipAllowedGids) so the result is available before viewports render —
+    // legend color maps must exist by then for fill: "legend".
     if (legend.clipToViewport) {
         const targetViewportId = legend.viewport;
-        const polys = targetViewportId ? viewportClipPolygonsLocal[targetViewportId] : null;
-        const vpInfo = targetViewportId ? viewportRenderInfo[targetViewportId] : null;
-        const t = isRecord(vpInfo) ? getProp(vpInfo, 'transform') : null;
-        if (polys && polys.length && isRecord(t)) {
-            const viewMinX = getProp(t, 'viewMinX');
-            const viewMaxZ = getProp(t, 'viewMaxZ');
-            if (typeof viewMinX === 'number' && typeof viewMaxZ === 'number') {
-                rows = rows.filter((row) => {
-                    const rowX = getProp(row, 'x');
-                    const rowZ = getProp(row, 'z');
-                    if (!Number.isFinite(rowX) || !Number.isFinite(rowZ)) return false;
-                    const viewX = Number(rowX) - viewMinX;
-                    const viewY = viewMaxZ - Number(rowZ);
-                    return polys.some((poly) => pointInPolygon(poly, viewX, viewY));
-                });
-            }
+        const polys = targetViewportId ? viewportClipPolygonsWorld[targetViewportId] : null;
+        if (polys && polys.length) {
+            const polys2D = polys.map((poly) => poly.map((p) => ({ x: p.x, y: p.z })));
+            rows = rows.filter((row) => {
+                const rowX = getProp(row, 'x');
+                const rowZ = getProp(row, 'z');
+                if (!Number.isFinite(rowX) || !Number.isFinite(rowZ)) return false;
+                return polys2D.some((poly) => pointInPolygon(poly, Number(rowX), Number(rowZ)));
+            });
         }
     }
 
     return rows;
 };
 
+/**
+ * Colors a legend assigned to its rows (assignColors), for consumption by
+ * viewport fill rules with `fill: "legend"`. Lookup order for an item:
+ * its gid (per-row identity — works without groupBy), then the value of the
+ * legend's groupBy property (shared across a group).
+ */
+export interface LegendColorAssignment {
+    /** The legend's groupBy property path, when set. */
+    groupBy?: string;
+    /** Row color by item gid/id. */
+    byGid: Map<string, string>;
+    /** Row color by groupBy property value (only populated with groupBy). */
+    byValue: Map<string, string>;
+}
+
 export interface LegendResult {
     svg: string;
-    colorMap?: Map<string, string>; // Maps property value to color
+    colors?: LegendColorAssignment;
 }
 
 export const buildLegendGroup = (
@@ -129,36 +138,25 @@ export const buildLegendGroup = (
 ): LegendResult | null => {
     if (!legend || !legendData || !legendData.length) return null;
 
-    // Debug: Log raw input data
-    // console.log(`[LEGEND INPUT] Received ${legendData.length} items for legend "${legend.id}"`);
-    // if (legend.groupBy) {
-    //   // Count duplicates by groupBy property
-    //   const counts = new Map<string, number>();
-    //   for (const item of legendData) {
-    //     const key = String(resolvePath(item, legend.groupBy) ?? '');
-    //     counts.set(key, (counts.get(key) || 0) + 1);
-    //   }
-    //   console.log('[LEGEND INPUT] Items per group (before grouping):', Array.from(counts.entries()).map(([k, v]) => `${k}: ${v}`).join(', '));
-    // }
-
     const pageMargin = typeof marginMm === 'number' ? marginMm : 0;
     const fontStyle = (legend.textStyle && styles?.[legend.textStyle]) || styles?.['body'];
     const fontSizeMm = typeof fontStyle?.fontSizeMm === 'number' ? fontStyle.fontSizeMm : 5;
-    const fontFamily = fontStyle?.fontFamily ?? 'Arial, sans-serif';
-    const fontColor = isRecord(fontStyle) ? (getProp(fontStyle, 'color') ?? '#000') : '#000';
+    // Escaped once here — every emitted <text>/<rect> below interpolates these
+    // (and cell text via escapeText) into XML.
+    const fontFamily = escapeAttr(String(fontStyle?.fontFamily ?? 'Arial, sans-serif'));
+    const fontColor = escapeAttr(String(isRecord(fontStyle) ? (getProp(fontStyle, 'color') ?? '#000') : '#000'));
 
     // Show color column if enabled (but swatches will be empty if no fills configured)
     const showColorColumn = legend.showColorColumn !== false;
     const colorColumnWidthMm = showColorColumn ? (legend.colorColumnWidthMm ?? DEFAULT_LEGEND_SWATCH_WIDTH_MM) : 0;
     const hasFills = fillOpacity !== undefined;
-    // console.log(`[LEGEND RENDER] fillOpacity=${fillOpacity}, hasFills=${hasFills}, showColorColumn=${showColorColumn}`);
     const cellPaddingMm = legend.cellPaddingMm ?? DEFAULT_LEGEND_CELL_PADDING_MM;
-    const borderStrokeWidthMm = legend.borderStrokeWidthMm ?? DEFAULT_LEGEND_BORDER_WIDTH_MM;
-    const borderStrokeColor = legend.borderStrokeColor ?? '#000000';
-    const gridStrokeWidthMm = legend.gridStrokeWidthMm ?? DEFAULT_LEGEND_GRID_WIDTH_MM;
-    const gridStrokeColor = legend.gridStrokeColor ?? '#000000';
-    const headerStrokeWidthMm = legend.headerStrokeWidthMm ?? DEFAULT_LEGEND_HEADER_WIDTH_MM;
-    const headerStrokeColor = legend.headerStrokeColor ?? '#000000';
+    const borderStrokeWidthMm = legend.border?.strokeWidthMm ?? DEFAULT_LEGEND_BORDER_WIDTH_MM;
+    const borderStrokeColor = escapeAttr(legend.border?.stroke ?? '#000000');
+    const gridStrokeWidthMm = legend.grid?.strokeWidthMm ?? DEFAULT_LEGEND_GRID_WIDTH_MM;
+    const gridStrokeColor = escapeAttr(legend.grid?.stroke ?? '#000000');
+    const headerStrokeWidthMm = legend.header?.strokeWidthMm ?? DEFAULT_LEGEND_HEADER_WIDTH_MM;
+    const headerStrokeColor = escapeAttr(legend.header?.stroke ?? '#000000');
     const anchor = legend.anchor ?? 'top-right';
     const legendMarginMm = legend.marginMm ?? DEFAULT_LEGEND_OFFSET_MM;
 
@@ -176,13 +174,6 @@ export const buildLegendGroup = (
             groups.get(groupKey)!.push(row);
         }
 
-        // console.log(`[LEGEND GROUPING] Total input rows: ${legendData.length}, Groups created: ${groups.size}`);
-        // for (const [key, rows] of groups.entries()) {
-        //   if (rows.length > 1) {
-        //     console.log(`[LEGEND GROUPING] Group "${key}": ${rows.length} rows`);
-        //   }
-        // }
-
         // Aggregate each group
         processedData = Array.from(groups.values()).map((groupRows) => {
             if (groupRows.length === 0) return groupRows[0];
@@ -217,16 +208,6 @@ export const buildLegendGroup = (
                         return acc + num;
                     }, 0);
 
-                    // Debug logging for aggregation
-                    // if (groupRows.length > 1 && legend.groupBy) {
-                    //   const groupKey = resolvePath(groupRows[0], legend.groupBy);
-                    //   console.log(`[LEGEND AGGREGATION] Group "${groupKey}", Column "${col.property}":`, {
-                    //     itemCount: values.length,
-                    //     values: values,
-                    //     sum: sum
-                    //   });
-                    // }
-
                     // Set the aggregated value in the nested property structure
                     const pathParts = col.property.split('.');
                     let target = aggregated;
@@ -245,29 +226,28 @@ export const buildLegendGroup = (
         });
     }
 
-    // Generate colors if assignColors is enabled
+    // Generate colors if assignColors is enabled — consumed by viewport fill
+    // rules with fill: "legend" (byGid works without groupBy: every row gets
+    // its own color).
     let generatedColors: string[] | null = null;
-    let colorMap: Map<string, string> | undefined;
+    let colors: LegendColorAssignment | undefined;
 
     if (legend.assignColors?.enabled) {
         const palette = legend.assignColors.palette ?? 'auto';
         generatedColors = generateLegendColors(processedData.length, palette);
-        // console.log(`[LEGEND COLORS] assignColors enabled, generated ${generatedColors.length} colors`);
-
-        // Build color map based on groupBy property
-        if (legend.groupBy) {
-            colorMap = new Map();
-            for (let i = 0; i < processedData.length; i++) {
-                const row = processedData[i];
+        colors = { groupBy: legend.groupBy || undefined, byGid: new Map(), byValue: new Map() };
+        for (let i = 0; i < processedData.length; i++) {
+            const row = processedData[i];
+            if (legend.groupBy) {
                 const groupValue = String(resolvePath(row, legend.groupBy) ?? '');
-                if (!colorMap.has(groupValue)) {
-                    colorMap.set(groupValue, generatedColors[i]);
-                    // console.log(`[LEGEND COLORS] Mapped "${groupValue}" -> ${generatedColors[i]}`);
+                if (!colors.byValue.has(groupValue)) {
+                    colors.byValue.set(groupValue, generatedColors[i]);
                 }
             }
-            // console.log(`[LEGEND COLORS] Generated ${colorMap.size} colors for groupBy="${legend.groupBy}"`);
-        } else {
-            console.warn(`[LEGEND COLORS] assignColors enabled but no groupBy property set`);
+            const gid = getProp(row, 'gid') ?? getProp(row, 'id');
+            if (gid !== null && gid !== undefined) {
+                colors.byGid.set(String(gid), generatedColors[i]);
+            }
         }
     }
 
@@ -405,7 +385,7 @@ export const buildLegendGroup = (
     for (let i = 2; i < columnCount; i++) {
         const x = originXmm + colXmm[i];
         lines.push(
-            `<line x1="${x}" y1="${originYmm}" x2="${x}" y2="${originYmm + tableHeightMm}" stroke="${gridStrokeColor}" stroke-width="${borderStrokeWidthMm}" />`
+            `<line x1="${x}" y1="${originYmm}" x2="${x}" y2="${originYmm + tableHeightMm}" stroke="${gridStrokeColor}" stroke-width="${gridStrokeWidthMm}" />`
         );
     }
 
@@ -415,7 +395,7 @@ export const buildLegendGroup = (
 
         const y = originYmm + headerHeightMm + r * rowHeightMm;
         lines.push(
-            `<line x1="${originXmm}" y1="${y}" x2="${originXmm + tableWidthMm}" y2="${y}" stroke="${gridStrokeColor}" stroke-width="${borderStrokeWidthMm}" />`
+            `<line x1="${originXmm}" y1="${y}" x2="${originXmm + tableWidthMm}" y2="${y}" stroke="${gridStrokeColor}" stroke-width="${gridStrokeWidthMm}" />`
         );
     }
 
@@ -433,7 +413,7 @@ export const buildLegendGroup = (
         const y = originYmm + headerHeightMm / 2 + textYOffsetMm;
         const anchorText = col.align === 'center' ? 'middle' : col.align === 'right' ? 'end' : 'start';
         texts.push(
-            `<text x="${x}" y="${y}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" dominant-baseline="middle" text-anchor="${anchorText}">${col.label}</text>`
+            `<text x="${x}" y="${y}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" dominant-baseline="middle" text-anchor="${anchorText}">${escapeText(col.label)}</text>`
         );
     });
 
@@ -449,7 +429,7 @@ export const buildLegendGroup = (
                 const swatchFill = row.color; // Already a CSS color string
                 const opacityAttr = swatchOpacity < 1 ? ` fill-opacity="${swatchOpacity.toFixed(3)}"` : '';
                 rects.push(
-                    `<rect x="${originXmm + colXmm[0]}" y="${yTop}" width="${colWidthsMm[0]}" height="${rowHeightMm}" fill="${swatchFill}"${opacityAttr} stroke="none" />`
+                    `<rect x="${originXmm + colXmm[0]}" y="${yTop}" width="${colWidthsMm[0]}" height="${rowHeightMm}" fill="${escapeAttr(String(swatchFill))}"${opacityAttr} stroke="none" />`
                 );
             } else {
                 // Empty swatch when no fills configured - just the border cell
@@ -474,7 +454,7 @@ export const buildLegendGroup = (
             const y = yTop + rowHeightMm / 2 + textYOffsetMm;
             const anchorText = col.align === 'center' ? 'middle' : col.align === 'right' ? 'end' : 'start';
             texts.push(
-                `<text x="${x}" y="${y}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" dominant-baseline="middle" text-anchor="${anchorText}">${text}</text>`
+                `<text x="${x}" y="${y}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" dominant-baseline="middle" text-anchor="${anchorText}">${escapeText(text)}</text>`
             );
         });
     });
@@ -514,7 +494,7 @@ export const buildLegendGroup = (
         const labelX = contentOriginXmm + innerPad;
         const labelY = yTop + rowHeightMm / 2 + textYOffsetMm;
         texts.push(
-            `<text x="${labelX}" y="${labelY}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" font-weight="bold" dominant-baseline="middle" text-anchor="start">${summaryLabel}</text>`
+            `<text x="${labelX}" y="${labelY}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" font-weight="bold" dominant-baseline="middle" text-anchor="start">${escapeText(summaryLabel)}</text>`
         );
 
         // Render summary values for other columns
@@ -533,11 +513,11 @@ export const buildLegendGroup = (
             const y = yTop + rowHeightMm / 2 + textYOffsetMm;
             const anchorText = col.align === 'center' ? 'middle' : col.align === 'right' ? 'end' : 'start';
             texts.push(
-                `<text x="${x}" y="${y}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" font-weight="bold" dominant-baseline="middle" text-anchor="${anchorText}">${summaryText}</text>`
+                `<text x="${x}" y="${y}" font-family="${fontFamily}" font-size="${fontSizeMm}" fill="${fontColor}" font-weight="bold" dominant-baseline="middle" text-anchor="${anchorText}">${escapeText(summaryText)}</text>`
             );
         });
     }
 
     const svg = [`<g id="legend">`, ...rects, ...lines, ...texts, `</g>`].join('');
-    return { svg, colorMap };
+    return { svg, colors };
 };

package/src/layout/metadata.ts

@@ -56,10 +56,15 @@ export const normalizePropertySets = (
         const source = isRecord(innerProps) ? innerProps : setValue;
         const props: Record<string, { value: unknown; unit?: string; type?: string }> = {};
         Object.entries(source).forEach(([propName, propVal]) => {
-            if (isRecord(propVal) && 'value' in propVal) {
-                props[propName] = propVal as { value: unknown; unit?: string; type?: string };
+            // T8 conflict arrays: T8PropertySet.properties values are
+            // T8Property | T8Property[] — multiple source files disagreed on
+            // the property. Use the first entry so the value stays scalar and
+            // filterable rather than leaking an array into `value`.
+            const single = Array.isArray(propVal) ? propVal[0] : propVal;
+            if (isRecord(single) && 'value' in single) {
+                props[propName] = single as { value: unknown; unit?: string; type?: string };
             } else {
-                props[propName] = { value: propVal };
+                props[propName] = { value: single };
             }
         });
         propertySets[setName] = props;
@@ -131,9 +136,16 @@ export const resolveIncludeClasses = (
             } else if (isRecord(item)) {
                 const cls = getProp(item, 'class');
                 const where = getProp(item, 'where');
+                const occludes = getProp(item, 'occludes');
+                const classify = getProp(item, 'classify');
                 // Must have either class or where (or both)
                 if (cls !== undefined || (where && isRecord(where))) {
-                    result.push({ class: cls as string | string[] | undefined, where: where as WhereCondition });
+                    result.push({
+                        class: cls as string | string[] | undefined,
+                        where: where as WhereCondition,
+                        ...(typeof occludes === 'boolean' ? { occludes } : {}),
+                        ...(typeof classify === 'boolean' ? { classify } : {})
+                    });
                 }
             }
         }
@@ -164,7 +176,16 @@ export const resolveIncludeClasses = (
 
         // Filter object: { class: "space", where: {...} }
         if (cls !== undefined || (where && isRecord(where))) {
-            return [{ class: cls as string | string[] | undefined, where: where as WhereCondition }];
+            const occludes = getProp(includeClasses, 'occludes');
+            const classify = getProp(includeClasses, 'classify');
+            return [
+                {
+                    class: cls as string | string[] | undefined,
+                    where: where as WhereCondition,
+                    ...(typeof occludes === 'boolean' ? { occludes } : {}),
+                    ...(typeof classify === 'boolean' ? { classify } : {})
+                }
+            ];
         }
     }
 

package/src/layout/model.ts

@@ -2,7 +2,7 @@ import type { SectionPath, SectionLabel } from '@twinfinity/geometry';
 import type { SvgModelView, ViewportElement, LabelStyle, ResolvedIncludeFilter } from './types';
 import type { ModelMetadata } from './metadata';
 import { resolveIncludeClasses, resolveMeta } from './metadata';
-import { normalizeClass, matchesWhere } from './filters';
+import { normalizeClass, classEquals, matchesWhere } from './filters';
 import { escapeAttr, escapeText } from './renderUtils';
 import { BUILTIN_LABEL_DEFAULTS } from './renderDrawing';
 
@@ -33,6 +33,7 @@ export const buildModelViewFromRaw = (
                 (path.stroke ? ` stroke="${escapeAttr(path.stroke)}"` : '') +
                 (path.strokeWidth ? ` stroke-width="${path.strokeWidth}"` : '') +
                 (path.strokeOpacity !== undefined ? ` stroke-opacity="${path.strokeOpacity}"` : '') +
+                (path.dash ? ` stroke-dasharray="${escapeAttr(path.dash)}"` : '') +
                 (path.fillRule ? ` fill-rule="${escapeAttr(path.fillRule)}"` : '') +
                 ` stroke-linejoin="round" stroke-linecap="round"` +
                 ` />`
@@ -102,13 +103,13 @@ const matchesIncludeFilter = (
     meta: unknown
 ): boolean => {
     for (const filter of includeFilters) {
-        // String filter: class name only
+        // String filter: class name only. classEquals treats the Ifc prefix
+        // as optional — same rule as every other class filter in the format.
         if (typeof filter === 'string') {
             const normalizedFilter = normalizeClass(filter);
-            if (cls && normalizedFilter === cls) return true;
+            if (cls && classEquals(normalizedFilter, cls)) return true;
             if (clsId && typeof clsId === 'string') {
-                const normalizedId = normalizeClass(clsId);
-                if (normalizedId === normalizedFilter) return true;
+                if (classEquals(normalizeClass(clsId), normalizedFilter)) return true;
             }
             continue;
         }
@@ -125,13 +126,12 @@ const matchesIncludeFilter = (
                 classMatches = false;
                 for (const c of classes) {
                     const normalizedC = normalizeClass(c);
-                    if (normalizedC && cls === normalizedC) {
+                    if (normalizedC && classEquals(cls, normalizedC)) {
                         classMatches = true;
                         break;
                     }
                     if (clsId && typeof clsId === 'string') {
-                        const normalizedId = normalizeClass(clsId);
-                        if (normalizedId === normalizedC) {
+                        if (classEquals(normalizeClass(clsId), normalizedC)) {
                             classMatches = true;
                             break;
                         }
@@ -161,9 +161,10 @@ export const filterModelForViewport = (
     highlight?: {
         gids: Set<string> | null;
         styles?: {
-            stroke?: string;
-            strokeWidthMm?: number;
-            strokeOpacity?: number;
+            color?: string;
+            widthMm?: number;
+            opacity?: number;
+            dash?: string;
             fill?: string;
             fillOpacity?: number;
         };
@@ -248,14 +249,17 @@ export const filterModelForViewport = (
         // Apply highlight styling when requested
         if (shouldHighlight) {
             const styledPath: SectionPath = { ...p };
-            if (highlight?.styles?.stroke !== undefined) {
-                styledPath.stroke = highlight.styles.stroke;
+            if (highlight?.styles?.color !== undefined) {
+                styledPath.stroke = highlight.styles.color;
             }
-            if (highlight?.styles?.strokeWidthMm !== undefined) {
-                styledPath.strokeWidth = highlight.styles.strokeWidthMm;
+            if (highlight?.styles?.widthMm !== undefined) {
+                styledPath.strokeWidth = highlight.styles.widthMm;
             }
-            if (highlight?.styles?.strokeOpacity !== undefined) {
-                styledPath.strokeOpacity = highlight.styles.strokeOpacity;
+            if (highlight?.styles?.opacity !== undefined) {
+                styledPath.strokeOpacity = highlight.styles.opacity;
+            }
+            if (highlight?.styles?.dash !== undefined) {
+                styledPath.dash = highlight.styles.dash;
             }
             if (highlight?.styles?.fill !== undefined) {
                 styledPath.fill = highlight.styles.fill;
@@ -304,55 +308,6 @@ export const filterModelForViewport = (
         filteredLabels.push(l);
     });
 
-    // Count paths by IFC class before and after filtering
-    const classCountsBefore = new Map<string, number>();
-    const classCountsAfter = new Map<string, number>();
-    const excluded: Array<{ cls: string | null; clsId: unknown }> = [];
-
-    model.rawPaths.forEach((p: SectionPath) => {
-        const rawMeta = getProp(p, 'meta');
-        const meta = resolveMeta(rawMeta, metadataById);
-        const metaFromMap = (() => {
-            const pid =
-                getProp(meta, 'productId') ??
-                getProp(meta, 'gid') ??
-                getProp(meta, 'id') ??
-                getProp(rawMeta, 'gid') ??
-                getProp(rawMeta, 'id');
-            return pid && metadataById ? metadataById[String(pid)] : null;
-        })();
-        const cls = normalizeClass(getProp(meta, 'ifcClass') ?? getProp(rawMeta, 'ifcClass') ?? metaFromMap?.ifcClass);
-        const clsId = getProp(meta, 'ifcClassId') ?? getProp(rawMeta, 'ifcClassId') ?? metaFromMap?.ifcClassId ?? null;
-        const key = cls ?? String(clsId) ?? 'unknown';
-        classCountsBefore.set(key, (classCountsBefore.get(key) ?? 0) + 1);
-    });
-
-    filteredPaths.forEach((p: SectionPath) => {
-        const rawMeta = getProp(p, 'meta');
-        const meta = resolveMeta(rawMeta, metadataById);
-        const metaFromMap = (() => {
-            const pid =
-                getProp(meta, 'productId') ??
-                getProp(meta, 'gid') ??
-                getProp(meta, 'id') ??
-                getProp(rawMeta, 'gid') ??
-                getProp(rawMeta, 'id');
-            return pid && metadataById ? metadataById[String(pid)] : null;
-        })();
-        const cls = normalizeClass(getProp(meta, 'ifcClass') ?? getProp(rawMeta, 'ifcClass') ?? metaFromMap?.ifcClass);
-        const clsId = getProp(meta, 'ifcClassId') ?? getProp(rawMeta, 'ifcClassId') ?? metaFromMap?.ifcClassId ?? null;
-        const key = cls ?? String(clsId) ?? 'unknown';
-        classCountsAfter.set(key, (classCountsAfter.get(key) ?? 0) + 1);
-    });
-
-    // Find excluded classes
-    classCountsBefore.forEach((countBefore, cls) => {
-        const countAfter = classCountsAfter.get(cls) ?? 0;
-        if (countAfter < countBefore) {
-            excluded.push({ cls, clsId: `${countBefore - countAfter} paths removed` });
-        }
-    });
-
     if (
         !styleMutated &&
         filteredPaths.length === model.rawPaths.length &&

package/src/layout/options.ts

@@ -3,7 +3,7 @@ import { ModelMetadata } from './metadata';
 export interface RenderLayoutOptions {
     scaleDenominators?: number[];
     maxViewports?: number;
-    allowRemoteAssets?: boolean;
+    allowRemoteResources?: boolean;
     allowDataUrls?: boolean;
     qrContext?: {
         host?: string | null;
@@ -11,7 +11,6 @@ export interface RenderLayoutOptions {
         floorName?: string | null;
         planeHeight?: number | null;
     };
-    legendSources?: Record<string, any[]>;
     /** Optional metadata map keyed by productId referenced from path/label meta */
     metadataById?: ModelMetadata;
 }