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

package/src/layout/preflight.ts

@@ -0,0 +1,96 @@
+import type { SectionRenderState } from '@twinfinity/geometry';
+import { validateLayoutTemplate } from './validation';
+import { validateSectionState } from './sectionValidation';
+import { isRecord, getProp } from './typeGuards';
+import type { LayoutTemplate, ValidationIssue, ValidationOptions } from './types';
+
+export type LayoutDataValidationResult =
+    | { ok: true }
+    | {
+          ok: false;
+          errors: string[];
+      };
+
+export type PreflightResult =
+    | { ok: true }
+    | {
+          ok: false;
+          templateErrors?: ValidationIssue[];
+          dataErrors?: string[];
+          sectionErrors?: string[];
+      };
+
+/**
+ * Validate template, layout data, and section state in a single call.
+ * Combines `validateLayoutTemplate`, `validateLayoutData`, and `validateSectionState`.
+ */
+export const preflight = (
+    template: LayoutTemplate,
+    data: unknown,
+    expectedViewportIds: string[],
+    sectionState?: SectionRenderState,
+    /**
+     * Forwarded to `validateLayoutTemplate`. Without it preflight always judged the template under
+     * default policy, so a caller that permits remote resources or data URLs was told its template
+     * was invalid by the very check meant to predict whether rendering would succeed.
+     */
+    options?: ValidationOptions
+): PreflightResult => {
+    const templateValidation = validateLayoutTemplate(template, options);
+    const dataValidation = validateLayoutData(data, expectedViewportIds);
+    const sectionValidation = sectionState ? validateSectionState(sectionState) : { ok: true as const };
+
+    const ok = templateValidation.ok && dataValidation.ok && sectionValidation.ok;
+    if (ok) return { ok: true };
+
+    return {
+        ok: false,
+        templateErrors: templateValidation.ok ? undefined : templateValidation.errors,
+        dataErrors: dataValidation.ok ? undefined : dataValidation.errors,
+        sectionErrors: sectionValidation.ok ? undefined : sectionValidation.errors
+    };
+};
+
+/**
+ * Validate layout data before rendering to catch missing propertySets or items arrays.
+ */
+export const validateLayoutData = (data: unknown, expectedViewportIds: string[]): LayoutDataValidationResult => {
+    const errors: string[] = [];
+    if (!isRecord(data)) {
+        return { ok: false, errors: ['layout data must be an object'] };
+    }
+    expectedViewportIds.forEach((vpId) => {
+        const viewports = getProp(data, 'viewports');
+        const viewport = isRecord(viewports) ? getProp(viewports, vpId) : undefined;
+        const items = getProp(viewport, 'items');
+        if (!Array.isArray(items)) {
+            errors.push(`viewports.${vpId}.items is required and must be an array.`);
+            return;
+        }
+        items.forEach((it: unknown, idx: number) => {
+            if (!isRecord(it)) {
+                errors.push(`viewports.${vpId}.items[${idx}] must be an object.`);
+                return;
+            }
+            const sets = getProp(it, 'propertySets');
+            if (!isRecord(sets)) {
+                errors.push(`viewports.${vpId}.items[${idx}] is missing propertySets.<Set>.<Prop>.value.`);
+                return;
+            }
+            Object.entries(sets).forEach(([setName, props]) => {
+                if (!isRecord(props)) {
+                    errors.push(`viewports.${vpId}.items[${idx}].propertySets.${setName} must be an object.`);
+                    return;
+                }
+                Object.entries(props).forEach(([propName, payload]) => {
+                    if (!isRecord(payload) || !('value' in payload)) {
+                        errors.push(
+                            `viewports.${vpId}.items[${idx}].propertySets.${setName}.${propName} must include a value (propertySets.<Set>.<Prop>.value).`
+                        );
+                    }
+                });
+            });
+        });
+    });
+    return errors.length ? { ok: false, errors } : { ok: true };
+};

package/src/layout/qrRender.ts

@@ -1,5 +1,6 @@
 import { escapeAttr } from './renderUtils';
-import { interpolate } from './renderUtils';
+import { interpolate, formatNumber } from './renderUtils';
+import { resolveViewportSection } from './sectionDefs';
 import { QrElement, SvgModelView } from './types';
 
 async function getQRCode(): Promise<typeof import('qrcode')> {
@@ -58,13 +59,18 @@ export const renderQrElements = async (
             const t = boundModel.transform;
             const worldX = t.viewMinX + modelX;
             const worldZ = t.viewMaxZ - modelY;
-            const planeHeight = options?.qrContext?.planeHeight ?? 0;
-            coordinate = { x: formatNumber(worldX), y: formatNumber(planeHeight ?? 0), z: formatNumber(worldZ) };
+            // Height: explicit qrContext wins; otherwise the bound viewport's
+            // own section definition (the template already knows its cut).
+            const sectionDef = resolveViewportSection(boundViewportDef);
+            const planeHeight = options?.qrContext?.planeHeight ?? (sectionDef?.plan ? sectionDef.position : 0);
+            coordinate = { x: formatNumber(worldX), y: formatNumber(planeHeight), z: formatNumber(worldZ) };
         }
 
         let payload: unknown = qr.dataTemplate ? interpolate(qr.dataTemplate, dataWithViewport) : null;
+        // Schema default: a QR with no role and no dataTemplate is role "main".
+        const role = qr.role ?? (qr.dataTemplate ? 'custom' : 'main');
         if (!payload || typeof payload === 'string') {
-            if (qr.role === 'anchor' && coordinate) {
+            if (role === 'anchor' && coordinate) {
                 const corner =
                     qr.anchorCorner === 'bottom-left'
                         ? 'bl'
@@ -76,7 +82,7 @@ export const renderQrElements = async (
                               ? 'tr'
                               : 'na';
                 payload = { v: 1, c: corner, p: coordinate };
-            } else if (qr.role === 'main') {
+            } else if (role === 'main') {
                 const cornerShort =
                     qr.anchorCorner === 'bottom-left'
                         ? 'bl'
@@ -119,8 +125,3 @@ export const renderQrElements = async (
 
     return parts;
 };
-
-const formatNumber = (value: number): number => {
-    if (!Number.isFinite(value)) return 0;
-    return Number.parseFloat(value.toFixed(3));
-};

package/src/layout/renderDrawing.ts

@@ -1,19 +1,21 @@
 import type { SectionRenderState, SectionPath, SectionLabel } from '@twinfinity/geometry';
-import { sectionStateToModelView, computePolylinesCenter } from './itemBuilders';
+import { sectionStateToModelView, computePolylinesCenter, readXZ } from './itemBuilders';
 import { buildMetadataMap, normalizePropertySets, resolveIfcClassName, resolveIfcClassId } from './metadata';
 import { applyLineStyleToPaths } from './utils';
 import { analyzeTemplate } from './analyzeTemplate';
-import { matchesV2Filter } from './filters';
+import { matchesFilter, matchesProductClass, normalizeValue } from './filters';
 import type {
     LayoutTemplate,
     ViewportElement,
     ViewportLineStyle,
+    ViewportLineStyles,
     FillRule,
     SvgModelView,
     SectionResult,
     RenderDrawingInput,
     RenderDrawingResult,
     NormalizedProductItem,
+    ProductPolylineEntry,
     LabelStyle
 } from './types';
 import { getProp } from './typeGuards';
@@ -133,43 +135,29 @@ function getSampleColor(): (product: unknown) => SampledColor | undefined {
     return _geometry.sampleProductColorRgba;
 }
 
-// Late-binding for renderLayout to break circular dependency.
-// renderDrawing is imported by index.ts which defines renderLayout.
-// The binding is set by index.ts after definition via setRenderLayoutBinding().
-let _renderLayout:
-    | ((
-          template: LayoutTemplate,
-          data: any,
-          models: Record<string, SvgModelView>,
-          options?: any
-      ) => Promise<{ svg: string; viewportScales: any; warnings: string[] }>)
-    | null = null;
-
-/** Called by index.ts to register renderLayout without a circular import. */
-export function setRenderLayoutBinding(fn: NonNullable<typeof _renderLayout>): void {
-    _renderLayout = fn;
-}
-
-function getRenderLayout(): NonNullable<typeof _renderLayout> {
-    if (!_renderLayout) {
-        throw new Error(
-            'renderLayout not initialized. Ensure @twinfinity/printing index is imported before calling renderDrawing.'
-        );
-    }
-    return _renderLayout;
-}
+import { renderLayout } from './renderLayout';
 
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
 /**
- * High-level entry point that converts raw plane-section results and a layout
- * template into a ready-to-print SVG string.
+ * High-level entry point that renders a layout template to a ready-to-print
+ * SVG string.
  *
- * Internalizes all data wiring (section → SVG, item extraction, color sampling,
- * metadata building, legend/label data) that previously required ~350 lines of
- * app-side boilerplate.
+ * The inputs form a 2×2 matrix — geometry × item data, each either raw or
+ * pre-built:
+ *
+ * | input                     | what it is                                       |
+ * |---------------------------|--------------------------------------------------|
+ * | `sections`                | RAW geometry: plane-section results (one shared or per viewport id). |
+ * | `models`                  | PRE-BUILT geometry: `SvgModelView`s per viewport id (e.g. from `slabSectionToModelView`). Needs `rawPaths` with `meta.gid` for highlight/clip/includeClasses. |
+ * | `options.productEntries`  | RAW item data: per-product world-x/z polylines (`slabPerProductToEntries`); one flat list shared by all viewports or a per-viewport record. Feeds labels/legend/clip/highlight items. |
+ * | `options.viewportItems`   | PRE-BUILT item data per viewport id (overrides `productEntries`).     |
+ *
+ * Prerequisite: products must have property sets loaded
+ * (`await api.ifc.loadPropertySets()` on core BIM objects) — without them
+ * every `where` filter matches nothing.
  *
  * ```ts
  * const section = computePlaneSectionsForProducts(products, plane, { includeInvisible: true });
@@ -177,9 +165,8 @@ function getRenderLayout(): NonNullable<typeof _renderLayout> {
  *   template,
  *   sections: { main: section },
  *   options: {
- *     allowRemoteAssets: true,
- *     qrContext: { host, containerName, planeHeight },
- *     productFields: { idPath: "propertySets.BIP.spacenumber.value", ... },
+ *     allowRemoteResources: true,
+ *     qrContext: { host, containerName },
  *     roomLabels: { labelPath: "BIP.spacename", classFilter: "space" },
  *   },
  * });
@@ -200,11 +187,9 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
         varWarnings.forEach((w) => warnings.push(`[Variables] ${w}`));
 
         // Apply variables to template (substitute {{vars.*}} references)
-        template = applyTemplateVariables(template, values);
+        template = applyTemplateVariables(template, values, warnings);
     }
 
-    const renderLayout = getRenderLayout();
-
     // ---- Collect viewport elements from template ----
     const viewports = template.elements.filter((el) => el.kind === 'viewport') as ViewportElement[];
     if (!viewports.length) {
@@ -213,6 +198,17 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
 
     // ---- Fast path: pre-built models provided directly ----
     if (input.models) {
+        if (options?.roomLabels) {
+            warnings.push('options.roomLabels is ignored on the models path — use a template labels element instead.');
+        }
+        // productEntries: one flat list for all viewports, or per-viewport record.
+        const entriesInput = options?.productEntries;
+        const entriesFor = (vpId: string): ProductPolylineEntry[] =>
+            Array.isArray(entriesInput) ? entriesInput : (entriesInput?.[vpId] ?? []);
+        const allEntries: ProductPolylineEntry[] = Array.isArray(entriesInput)
+            ? entriesInput
+            : Object.values(entriesInput ?? {}).flat();
+
         // Build items: explicit viewportItems take priority, then auto-build from productEntries
         let viewportsData: Record<string, { items: NormalizedProductItem[] }>;
 
@@ -221,13 +217,13 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
                 viewports.map((vp) => [vp.id, { items: [] as NormalizedProductItem[] }])
             );
             viewportsData = { ...emptyDefaults, ...options.viewportItems };
-        } else if (options?.productEntries?.length) {
+        } else if (allEntries.length) {
             // Auto-build items per viewport from raw product entries
             const sampleColor = getSampleColor();
             viewportsData = {};
             for (const vp of viewports) {
                 viewportsData[vp.id] = {
-                    items: buildItemsFromEntries(options.productEntries, vp.fills, sampleColor)
+                    items: buildItemsFromEntries(entriesFor(vp.id), vp.fills, sampleColor)
                 };
             }
         } else {
@@ -258,18 +254,29 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
                     warnings.push(`Template references property '${path}' but no items provide it.`);
                 }
             }
+        } else if (
+            reqs.propertyPaths.length > 0 ||
+            template.elements.some((el) => el.kind === 'labels' || el.kind === 'legend')
+        ) {
+            // Item-driven features with zero items is almost always a missing
+            // productEntries/viewportItems input, not an intentionally empty sheet.
+            warnings.push(
+                'Template uses item data (labels/legend/where-filters) but no items were provided — pass options.productEntries or options.viewportItems.'
+            );
         }
 
-        if (reqs.usesRemoteAssets && !template.allowRemoteAssets && !options?.allowRemoteAssets) {
-            warnings.push('Template uses remote assets but allowRemoteAssets is not enabled.');
+        if (reqs.usesRemoteResources && !template.allowRemoteResources && !options?.allowRemoteResources) {
+            warnings.push('Template uses remote resources but allowRemoteResources is not enabled.');
         }
 
         // Build metadata from product entries (same as standard path)
-        const metadataEntries = options?.productEntries ?? [];
-        const metadataById = buildMetadataMap(metadataEntries);
+        // Caller-supplied metadata first: entries only cover cut-bearing products, but
+        // include filtering must classify products whose geometry never crosses the cut
+        // (furniture below a plan cut) - renderTemplateSheet supplies the full map.
+        const metadataById = { ...(options?.metadataById ?? {}), ...buildMetadataMap(allEntries) };
 
         const result = await renderLayout(template, layoutData, input.models, {
-            allowRemoteAssets: template.allowRemoteAssets ?? options?.allowRemoteAssets,
+            allowRemoteResources: template.allowRemoteResources ?? options?.allowRemoteResources,
             qrContext: options?.qrContext,
             metadataById
         });
@@ -302,7 +309,6 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
     // ---- Build section state + model view per viewport ----
     const models: Record<string, SvgModelView> = {};
     const entriesByViewport: Record<string, SectionResult['perProduct']> = {};
-    const sectionStateCache = new Map<string, SectionRenderState | null>();
 
     for (const vp of viewports) {
         const sectionResult = sections[vp.id];
@@ -313,39 +319,44 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
 
         entriesByViewport[vp.id] = sectionResult.perProduct;
 
-        // Dedup: skip if already built for this viewport key
-        if (sectionStateCache.has(vp.id)) {
-            const cached = sectionStateCache.get(vp.id);
-            if (cached) {
-                models[vp.id] = sectionStateToModelView(cached);
-            }
-            continue;
-        }
-
         const resolved = resolveLineStyles(vp);
 
         // Estimate label font size from template style and section bounds
         const labelFontSize = estimateLabelFontSize(template, vp, sectionResult.perProduct);
 
-        // Extract clip polygon from section results if clip config is present
+        // Extract clip polygon from section results if clip config is present.
+        // Matching semantics MUST mirror matchesFilter (viewportPrep/labels/
+        // legend all use it on the same clip config): class optional,
+        // Ifc prefix optional, case-insensitive values, arrays mean any-of.
         let clipPolygon: Array<Array<{ x: number; z: number }>> | undefined;
-        if (vp.clip?.where && vp.clip.class) {
-            const clipClass = Array.isArray(vp.clip.class) ? vp.clip.class : [vp.clip.class];
+        if (vp.clip?.where) {
+            const clipClass = vp.clip.class ? (Array.isArray(vp.clip.class) ? vp.clip.class : [vp.clip.class]) : null;
             const clipEntries = sectionResult.perProduct.filter((entry: any) => {
                 const product = entry.product;
-                const matchesClass = clipClass.some((c: string) => product.class?.is?.(c));
-                if (!matchesClass) return false;
-                // Match where condition using T8-aware property resolution
+                // Shared helper rather than product.class.is(): that compares with ===, so a clip
+                // filter of "SPACE" or "IFCWALL" selected nothing while labels and legend — reading
+                // the same clip config through matchesFilter — matched it. The clip silently did
+                // not apply, with no warning anywhere.
+                if (!matchesProductClass(product, clipClass ?? undefined)) return false;
                 for (const [path, expected] of Object.entries(vp.clip!.where!)) {
-                    const actualValue = resolveProductProperty(product, path);
-                    if (actualValue === undefined) return false;
-                    if (actualValue !== expected) return false;
+                    const actual = normalizeValue(resolveProductProperty(product, path));
+                    const matches = Array.isArray(expected)
+                        ? expected.some((v) => normalizeValue(v) === actual)
+                        : actual === normalizeValue(expected);
+                    if (!matches) return false;
                 }
                 return true;
             });
             if (clipEntries.length) {
                 clipPolygon = clipEntries.flatMap((entry: any) =>
-                    (entry.polylines || []).map((pl: any) => (pl.points || []).map((p: any) => ({ x: p.x, z: p.z })))
+                    (entry.polylines || []).map((pl: any) =>
+                        (pl.points || [])
+                            .map((p: any) => readXZ(p))
+                            .filter(
+                                (p: { x: number | null; z: number | null }): p is { x: number; z: number } =>
+                                    p.x !== null && p.z !== null
+                            )
+                    )
                 );
             }
         }
@@ -374,8 +385,6 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
             planeNormal
         });
 
-        sectionStateCache.set(vp.id, state);
-
         if (!state) {
             warnings.push(`No geometry for viewport '${vp.id}'.`);
             continue;
@@ -423,7 +432,10 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
 
     // ---- Build metadata from all section entries ----
     const allEntries = Object.values(entriesByViewport).flat();
-    const metadataById = buildMetadataMap(allEntries);
+    // Caller-supplied metadata first: entries only cover cut-bearing products, but
+    // include filtering must classify products whose geometry never crosses the cut
+    // (furniture below a plan cut) - renderTemplateSheet supplies the full map.
+    const metadataById = { ...(options?.metadataById ?? {}), ...buildMetadataMap(allEntries) };
 
     // ---- Assemble layout data ----
     const layoutData = {
@@ -432,7 +444,7 @@ export async function renderDrawing(input: RenderDrawingInput): Promise<RenderDr
 
     // ---- Render ----
     const result = await renderLayout(template, layoutData, models, {
-        allowRemoteAssets: template.allowRemoteAssets ?? options?.allowRemoteAssets,
+        allowRemoteResources: template.allowRemoteResources ?? options?.allowRemoteResources,
         qrContext: options?.qrContext,
         metadataById
     });
@@ -511,13 +523,12 @@ function estimateLabelFontSize(
         for (const polyline of entry.polylines) {
             if (!polyline.points) continue;
             for (const pt of polyline.points) {
-                const px = getProp(pt, 'x');
-                const pz = getProp(pt, 'z');
-                if (Number.isFinite(px) && Number.isFinite(pz)) {
-                    if ((px as number) < minX) minX = px as number;
-                    if ((px as number) > maxX) maxX = px as number;
-                    if ((pz as number) < minZ) minZ = pz as number;
-                    if ((pz as number) > maxZ) maxZ = pz as number;
+                const { x: px, z: pz } = readXZ(pt);
+                if (px !== null && pz !== null) {
+                    if (px < minX) minX = px;
+                    if (px > maxX) maxX = px;
+                    if (pz < minZ) minZ = pz;
+                    if (pz > maxZ) maxZ = pz;
                 }
             }
         }
@@ -571,11 +582,12 @@ export const BUILTIN_HIDDEN_DEFAULTS: Required<ViewportLineStyle> = {
     enabled: true
 };
 
-type LineCategory =
+export type LineCategory =
     | 'cutLines'
     | 'visibleLines'
     | 'hiddenLines'
-    | 'silhouettes'
+    | 'silhouettesVisible'
+    | 'silhouettesHidden'
     | 'featureEdges'
     | 'stairArrows'
     | 'outlineVisible'
@@ -585,28 +597,59 @@ type LineCategory =
 export const CATEGORY_BUILTIN_OVERRIDES: Partial<Record<LineCategory, Partial<ViewportLineStyle>>> = {
     cutLines: { widthMm: 0.02 },
     hiddenLines: BUILTIN_HIDDEN_DEFAULTS,
+    // Occluded silhouettes follow the hidden drafting convention out of the box.
+    silhouettesHidden: BUILTIN_HIDDEN_DEFAULTS,
     outlineHidden: BUILTIN_HIDDEN_DEFAULTS
 };
 
+/** Visibility group of each category; keyed to the `defaultVisibleLines`/`defaultHiddenLines` template keys. `stairArrows` is annotation, not geometry, and belongs to neither group. */
+const CATEGORY_VISIBILITY_GROUP: Partial<Record<LineCategory, 'defaultVisibleLines' | 'defaultHiddenLines'>> = {
+    cutLines: 'defaultVisibleLines',
+    visibleLines: 'defaultVisibleLines',
+    silhouettesVisible: 'defaultVisibleLines',
+    silhouettesHidden: 'defaultHiddenLines',
+    featureEdges: 'defaultVisibleLines',
+    outlineVisible: 'defaultVisibleLines',
+    hiddenLines: 'defaultHiddenLines',
+    outlineHidden: 'defaultHiddenLines'
+};
+
+/**
+ * Resolve the effective line style for one category — the single source of
+ * truth used by both the slab plan path (slabModelView) and the drawing path.
+ *
+ * Cascade, weakest first: built-in defaults → `default` → built-in category
+ * defaults → `defaultVisibleLines`/`defaultHiddenLines` (the category's
+ * visibility group) → the category's own key.
+ */
+export function resolveCategoryLineStyle(
+    category: LineCategory,
+    lineStyles?: ViewportLineStyles
+): Required<ViewportLineStyle> {
+    const group = CATEGORY_VISIBILITY_GROUP[category];
+    return {
+        ...BUILTIN_LINE_DEFAULTS,
+        ...(lineStyles?.default ?? {}),
+        ...(CATEGORY_BUILTIN_OVERRIDES[category] ?? {}),
+        ...((group && lineStyles?.[group]) ?? {}),
+        ...(lineStyles?.[category] ?? {})
+    } as Required<ViewportLineStyle>;
+}
+
 export interface ResolvedLineStyles {
     default: Required<ViewportLineStyle>;
     byCategory: Record<LineCategory, Required<ViewportLineStyle>>;
 }
 
 /**
- * Resolve the effective line style for every category.
- *
- * Priority: category entry in `lineStyles` → `lineStyles.default`
- *         → `lineWidthMm`/`lineColor` shorthand → built-in defaults.
+ * Resolve the effective line style for every category via
+ * {@link resolveCategoryLineStyle} (shared with the slab plan path).
  */
 function resolveLineStyles(vp: ViewportElement): ResolvedLineStyles {
     const ls = vp.lineStyles;
 
-    // Base default: lineStyles.default → shorthand → built-in
     const base: Required<ViewportLineStyle> = {
         ...BUILTIN_LINE_DEFAULTS,
-        ...(vp.lineWidthMm !== undefined ? { widthMm: vp.lineWidthMm } : {}),
-        ...(vp.lineColor !== undefined ? { color: vp.lineColor } : {}),
         ...(ls?.default ?? {})
     } as Required<ViewportLineStyle>;
 
@@ -614,38 +657,17 @@ function resolveLineStyles(vp: ViewportElement): ResolvedLineStyles {
         'cutLines',
         'visibleLines',
         'hiddenLines',
-        'silhouettes',
+        'silhouettesVisible',
+        'silhouettesHidden',
         'featureEdges',
         'stairArrows',
         'outlineVisible',
         'outlineHidden'
     ];
 
-    // Category group mapping: individual categories inherit from their group style
-    const categoryGroups: Record<LineCategory, LineCategory> = {
-        cutLines: 'visibleLines',
-        visibleLines: 'visibleLines',
-        silhouettes: 'visibleLines',
-        featureEdges: 'visibleLines',
-        outlineVisible: 'visibleLines',
-        hiddenLines: 'hiddenLines',
-        outlineHidden: 'hiddenLines',
-        stairArrows: 'stairArrows'
-    };
-
     const byCategory = {} as Record<LineCategory, Required<ViewportLineStyle>>;
     for (const cat of categories) {
-        const builtinOverride = CATEGORY_BUILTIN_OVERRIDES[cat];
-        const groupName = categoryGroups[cat];
-        const groupStyle = ls?.[groupName]; // Group style (visibleLines, hiddenLines, stairArrows)
-        const categoryOverride = ls?.[cat]; // Individual category settings (enable/disable)
-
-        byCategory[cat] = {
-            ...base,
-            ...(builtinOverride ?? {}),
-            ...(groupStyle ?? {}), // Apply group style first
-            ...(categoryOverride ?? {}) // Then individual overrides (enable/disable)
-        } as Required<ViewportLineStyle>;
+        byCategory[cat] = resolveCategoryLineStyle(cat, ls);
     }
 
     return { default: base, byCategory };
@@ -667,7 +689,7 @@ export function resolveFillColor(
 ): [number, number, number, number] | undefined {
     if (!fills?.length) return undefined;
     for (const rule of fills) {
-        if (!matchesV2Filter(item, rule.class, rule.where)) continue;
+        if (!matchesFilter(item, rule.class, rule.where)) continue;
         if (rule.fill === 'sample') {
             const sampled = sampleColor(product);
             if (sampled) {