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

package/dist/types.js

@@ -2,7 +2,16 @@ export const DEFAULT_SVG_STYLES = {
     cutLines: { enabled: true, stroke: '#dc2626', strokeWidth: 0.01, opacity: 1 },
     visibleLines: { enabled: true, stroke: '#111827', strokeWidth: 0.005, opacity: 1 },
     hiddenLines: { enabled: true, stroke: '#6b7280', strokeWidth: 0.004, strokeDasharray: '0.02,0.01', opacity: 1 },
-    silhouettes: { enabled: true, stroke: '#000000', strokeWidth: 0.006, opacity: 1 },
+    silhouettesVisible: { enabled: true, stroke: '#000000', strokeWidth: 0.006, opacity: 1 },
+    // Hidden contours follow the hiddenLines drafting convention (dashed grey), not the
+    // visible outline's heavy solid stroke.
+    silhouettesHidden: {
+        enabled: true,
+        stroke: '#6b7280',
+        strokeWidth: 0.004,
+        strokeDasharray: '0.02,0.01',
+        opacity: 1
+    },
     featureEdges: { enabled: true, stroke: '#374151', strokeWidth: 0.005, opacity: 1 },
     stairArrows: { enabled: true, stroke: '#111827', strokeWidth: 0.005, opacity: 1 },
     outlineVisible: { enabled: true, stroke: '#111827', strokeWidth: 0.004, opacity: 1 },

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"/","sources":["types.ts"],"names":[],"mappings":"AAuCA,MAAM,CAAC,MAAM,kBAAkB,GAA8B;IACzD,QAAQ,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE;IAC7E,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IAClF,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE;IAC/G,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IACjF,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IAClF,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IACjF,cAAc,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IACpF,aAAa,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,EAAE;CACtH,CAAC","sourcesContent":["/** Line styling options for SVG rendering. */\nexport interface SvgLineStyle {\n    enabled?: boolean;\n    stroke?: string;\n    strokeWidth?: number;\n    strokeDasharray?: string;\n    opacity?: number;\n}\n\n/** Style configuration for different line categories in SVG rendering. */\nexport interface SvgRenderStyles {\n    cutLines?: SvgLineStyle;\n    visibleLines?: SvgLineStyle;\n    hiddenLines?: SvgLineStyle;\n    silhouettes?: SvgLineStyle;\n    featureEdges?: SvgLineStyle;\n    stairArrows?: SvgLineStyle;\n    outlineVisible?: SvgLineStyle;\n    outlineHidden?: SvgLineStyle;\n}\n\n/** Plane basis for projecting 3D points to 2D. */\nexport interface SvgPlaneBasis {\n    origin: { x: number; y: number; z: number };\n    right: { x: number; y: number; z: number };\n    up: { x: number; y: number; z: number };\n}\n\n/** Options for printToSvg. */\nexport interface PrintToSvgOptions {\n    viewBox?: [number, number, number, number];\n    styles?: SvgRenderStyles;\n    includeXmlDeclaration?: boolean;\n    backgroundColor?: string;\n    planeBasis?: SvgPlaneBasis;\n    bounds?: { minX: number; maxX: number; minY: number; maxY: number };\n    boundsPadding?: number;\n}\n\nexport const DEFAULT_SVG_STYLES: Required<SvgRenderStyles> = {\n    cutLines: { enabled: true, stroke: '#dc2626', strokeWidth: 0.01, opacity: 1 },\n    visibleLines: { enabled: true, stroke: '#111827', strokeWidth: 0.005, opacity: 1 },\n    hiddenLines: { enabled: true, stroke: '#6b7280', strokeWidth: 0.004, strokeDasharray: '0.02,0.01', opacity: 1 },\n    silhouettes: { enabled: true, stroke: '#000000', strokeWidth: 0.006, opacity: 1 },\n    featureEdges: { enabled: true, stroke: '#374151', strokeWidth: 0.005, opacity: 1 },\n    stairArrows: { enabled: true, stroke: '#111827', strokeWidth: 0.005, opacity: 1 },\n    outlineVisible: { enabled: true, stroke: '#111827', strokeWidth: 0.004, opacity: 1 },\n    outlineHidden: { enabled: true, stroke: '#9ca3af', strokeWidth: 0.003, strokeDasharray: '0.015,0.008', opacity: 1 }\n};\n"]}
+{"version":3,"file":"types.js","sourceRoot":"/","sources":["types.ts"],"names":[],"mappings":"AAwCA,MAAM,CAAC,MAAM,kBAAkB,GAA8B;IACzD,QAAQ,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE;IAC7E,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IAClF,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE;IAC/G,kBAAkB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IACxF,oFAAoF;IACpF,wCAAwC;IACxC,iBAAiB,EAAE;QACf,OAAO,EAAE,IAAI;QACb,MAAM,EAAE,SAAS;QACjB,WAAW,EAAE,KAAK;QAClB,eAAe,EAAE,WAAW;QAC5B,OAAO,EAAE,CAAC;KACb;IACD,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IAClF,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IACjF,cAAc,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IACpF,aAAa,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,EAAE;CACtH,CAAC","sourcesContent":["/** Line styling options for SVG rendering. */\nexport interface SvgLineStyle {\n    enabled?: boolean;\n    stroke?: string;\n    strokeWidth?: number;\n    strokeDasharray?: string;\n    opacity?: number;\n}\n\n/** Style configuration for different line categories in SVG rendering. */\nexport interface SvgRenderStyles {\n    cutLines?: SvgLineStyle;\n    visibleLines?: SvgLineStyle;\n    hiddenLines?: SvgLineStyle;\n    silhouettesVisible?: SvgLineStyle;\n    silhouettesHidden?: SvgLineStyle;\n    featureEdges?: SvgLineStyle;\n    stairArrows?: SvgLineStyle;\n    outlineVisible?: SvgLineStyle;\n    outlineHidden?: SvgLineStyle;\n}\n\n/** Plane basis for projecting 3D points to 2D. */\nexport interface SvgPlaneBasis {\n    origin: { x: number; y: number; z: number };\n    right: { x: number; y: number; z: number };\n    up: { x: number; y: number; z: number };\n}\n\n/** Options for printToSvg. */\nexport interface PrintToSvgOptions {\n    viewBox?: [number, number, number, number];\n    styles?: SvgRenderStyles;\n    includeXmlDeclaration?: boolean;\n    backgroundColor?: string;\n    planeBasis?: SvgPlaneBasis;\n    bounds?: { minX: number; maxX: number; minY: number; maxY: number };\n    boundsPadding?: number;\n}\n\nexport const DEFAULT_SVG_STYLES: Required<SvgRenderStyles> = {\n    cutLines: { enabled: true, stroke: '#dc2626', strokeWidth: 0.01, opacity: 1 },\n    visibleLines: { enabled: true, stroke: '#111827', strokeWidth: 0.005, opacity: 1 },\n    hiddenLines: { enabled: true, stroke: '#6b7280', strokeWidth: 0.004, strokeDasharray: '0.02,0.01', opacity: 1 },\n    silhouettesVisible: { enabled: true, stroke: '#000000', strokeWidth: 0.006, opacity: 1 },\n    // Hidden contours follow the hiddenLines drafting convention (dashed grey), not the\n    // visible outline's heavy solid stroke.\n    silhouettesHidden: {\n        enabled: true,\n        stroke: '#6b7280',\n        strokeWidth: 0.004,\n        strokeDasharray: '0.02,0.01',\n        opacity: 1\n    },\n    featureEdges: { enabled: true, stroke: '#374151', strokeWidth: 0.005, opacity: 1 },\n    stairArrows: { enabled: true, stroke: '#111827', strokeWidth: 0.005, opacity: 1 },\n    outlineVisible: { enabled: true, stroke: '#111827', strokeWidth: 0.004, opacity: 1 },\n    outlineHidden: { enabled: true, stroke: '#9ca3af', strokeWidth: 0.003, strokeDasharray: '0.015,0.008', opacity: 1 }\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinfinity/printing",
-  "version": "6.1.0-beta",
+  "version": "6.1.2-ci.30738-beta",
   "description": "SVG and PDF output",
   "license": "ISC",
   "main": "dist/index.js",
@@ -24,7 +24,9 @@
     "setVersion": "bun run ../scripts/set-version.mts twinfinity-printing beta"
   },
   "dependencies": {
-    "@twinfinity/geometry": "6.1.0-beta"
+    "@twinfinity/geometry": "6.1.2-ci.30738-beta",
+    "@twinfinity/product-geometry": "6.1.2-ci.30738-beta",
+    "polygon-clipping": "^0.15.7"
   },
   "peerDependencies": {
     "jspdf": "^2.5.1",
@@ -43,7 +45,10 @@
     }
   },
   "devDependencies": {
+    "ajv": "^8.17.1",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.3",
+    "jspdf": "^2.5.1",
+    "svg2pdf.js": "^2.0.0"
   }
 }

package/src/index.ts

@@ -8,3 +8,7 @@ export * from './layout/index';
 
 // Sections SVG viewport module
 export * from './sections';
+
+// Template-schema utilities (snippet-placeholder sanitizing for consumers
+// that parse the shipped template-schema.json)
+export { sanitizeTemplateSchemaSnippets } from './schemaUtils';

package/src/layout/analyzeTemplate.ts

@@ -1,4 +1,5 @@
 import { normalizeClass } from './filters';
+import { splitPlaceholder } from './renderUtils';
 import type {
     LayoutTemplate,
     LayoutElement,
@@ -28,25 +29,26 @@ export interface TemplateRequirements {
     /** Class filters referenced (e.g. "space", "walls"). Already lowercase. */
     classFilters: string[];
 
-    /** Asset IDs referenced by image/northArrow elements. */
-    assetIds: string[];
+    /** Resource IDs referenced by image/northArrow elements. */
+    resourceIds: string[];
 
     /** Text interpolation variables (e.g. "viewport.main.scaleText"). */
     interpolationVars: string[];
 
-    /** Whether the template references remote (http/https) asset URLs. */
-    usesRemoteAssets: boolean;
+    /** Whether the template references remote (http/https) resource URLs. */
+    usesRemoteResources: boolean;
 }
 
 const INTERPOLATION_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
 
-/** Extract `{{path}}` tokens from a template string. */
+/** Extract `{{path}}` tokens from a template string (format filters like
+ *  `| round:1` are part of the placeholder, not the referenced path). */
 function extractInterpolationVars(text: string): string[] {
     const vars: string[] = [];
     let m: RegExpExecArray | null;
     INTERPOLATION_RE.lastIndex = 0;
     while ((m = INTERPOLATION_RE.exec(text)) !== null) {
-        vars.push(m[1]);
+        vars.push(splitPlaceholder(m[1]).path);
     }
     return vars;
 }
@@ -80,15 +82,15 @@ export function analyzeTemplate(template: LayoutTemplate): TemplateRequirements
     const viewportIds = new Set<string>();
     const propertyPaths = new Set<string>();
     const classFilters = new Set<string>();
-    const assetIds = new Set<string>();
+    const resourceIds = new Set<string>();
     const interpolationVars = new Set<string>();
-    let usesRemoteAssets = false;
+    let usesRemoteResources = false;
 
-    // Check assets for remote URLs
-    if (template.assets) {
-        for (const asset of template.assets) {
-            if (asset.src && /^https?:\/\//i.test(asset.src)) {
-                usesRemoteAssets = true;
+    // Check resources for remote URLs
+    if (template.resources) {
+        for (const resource of template.resources) {
+            if (resource.src && /^https?:\/\//i.test(resource.src)) {
+                usesRemoteResources = true;
             }
         }
     }
@@ -124,9 +126,9 @@ export function analyzeTemplate(template: LayoutTemplate): TemplateRequirements
                         // Preset references are resolved at render time, nothing to collect
                     }
 
-                    // North arrow asset
-                    if (vp.northArrow?.assetId) {
-                        assetIds.add(vp.northArrow.assetId);
+                    // North arrow resource
+                    if (vp.northArrow?.resourceId) {
+                        resourceIds.add(vp.northArrow.resourceId);
                     }
                     break;
                 }
@@ -143,7 +145,7 @@ export function analyzeTemplate(template: LayoutTemplate): TemplateRequirements
 
                 case 'image': {
                     const img = el as ImageElement;
-                    if (img.assetId) assetIds.add(img.assetId);
+                    if (img.resourceId) resourceIds.add(img.resourceId);
                     break;
                 }
 
@@ -211,8 +213,8 @@ export function analyzeTemplate(template: LayoutTemplate): TemplateRequirements
         viewportIds: [...viewportIds],
         propertyPaths: [...propertyPaths],
         classFilters: [...classFilters],
-        assetIds: [...assetIds],
+        resourceIds: [...resourceIds],
         interpolationVars: [...interpolationVars],
-        usesRemoteAssets
+        usesRemoteResources
     };
 }

package/src/layout/classClosure.ts

@@ -0,0 +1,142 @@
+/**
+ * Per-viewport compute-class closure (TWINS-3784 perf + semantics): the set of classes a
+ * single viewport's drawing generation may touch — its resolved includeClasses, its
+ * highlight/clip classes, its fill rules, and any labels/legend elements bound to it.
+ *
+ * The contract (decided with TWINS-3784): only the viewport's include classes take part
+ * in that viewport's drawing generation, HIDDEN LINES INCLUDED — geometry outside the
+ * closure neither draws nor occludes there (an undrawable pipe run must not hide the
+ * wall behind it), and does not pay compute cost. Sections are cached per
+ * (sectionDef, closure), so viewports sharing both share the geometry.
+ *
+ * Returns null when the viewport's closure cannot be bounded by class: no includeClasses
+ * (the viewport draws everything) or any feature filtered only by a where-condition. The
+ * caller then computes that viewport with all products — the previous behaviour.
+ */
+
+import { normalizeClass } from './filters';
+import { resolveIncludeClasses } from './metadata';
+import { isRecord, getProp } from './typeGuards';
+import type { LayoutTemplate } from './types';
+
+export function computeViewportClassClosure(vp: Record<string, unknown>, template: LayoutTemplate): Set<string> | null {
+    const presets = template.presets?.includeClasses ?? {};
+    const out = new Set<string>();
+
+    /** Add class name(s); false = value present but not class-expressible. */
+    const addClasses = (cls: unknown): boolean => {
+        if (typeof cls === 'string') {
+            const n = normalizeClass(cls);
+            if (n) out.add(n);
+            return n !== null;
+        }
+        if (Array.isArray(cls)) {
+            if (!cls.length) return false;
+            let ok = true;
+            for (const c of cls) ok = addClasses(c) && ok;
+            return ok;
+        }
+        return false;
+    };
+
+    const resolved = resolveIncludeClasses(getProp(vp, 'includeClasses'), presets);
+    if (!resolved) return null; // no includeClasses ⇒ the viewport draws everything
+    for (const f of resolved) {
+        if (typeof f === 'string') {
+            if (!addClasses(f)) return null;
+        } else if (f.class !== undefined) {
+            // A where-condition narrows WITHIN the class — class superset is safe.
+            if (!addClasses(f.class)) return null;
+        } else {
+            return null; // where-only include filter — class-unbounded
+        }
+    }
+    for (const key of ['highlight', 'clip']) {
+        const cfg = getProp(vp, key);
+        if (cfg == null) continue;
+        if (!isRecord(cfg) || !addClasses(getProp(cfg, 'class'))) return null;
+    }
+    const fills = getProp(vp, 'fills');
+    if (Array.isArray(fills)) {
+        for (const rule of fills) {
+            if (!isRecord(rule) || !addClasses(getProp(rule, 'class'))) return null;
+        }
+    }
+
+    // Labels/legend elements bound to this viewport (recursing into groups). An element
+    // without a viewport binding is treated as bound to every viewport — conservative.
+    const vpId = getProp(vp, 'id');
+    let bounded = true;
+    const visit = (elements: unknown): void => {
+        if (!Array.isArray(elements) || !bounded) return;
+        for (const el of elements) {
+            if (!isRecord(el)) continue;
+            const kind = getProp(el, 'kind');
+            if (kind === 'labels' || kind === 'legend') {
+                const boundTo = getProp(el, 'viewport');
+                if (boundTo === undefined || boundTo === vpId) {
+                    if (!addClasses(getProp(el, 'class'))) {
+                        bounded = false;
+                        return;
+                    }
+                }
+            }
+            const children = getProp(el, 'children');
+            if (children !== undefined) visit(children);
+        }
+    };
+    visit(template.elements);
+    if (!bounded) return null;
+
+    return out.size > 0 ? out : null;
+}
+
+/** Per-class drawing-generation behavior extracted from includeClasses entries. */
+export interface ClassBehaviorRule {
+    class: string | string[];
+    occludes?: boolean;
+    classify?: boolean;
+}
+
+/**
+ * Collects per-class behavior flags (TWINS-3784) from the viewport's includeClasses
+ * entries: `{ "class": "pipes", "occludes": false, "classify": false }`. Flags apply
+ * class-wide — a `where` on the same entry narrows what is DRAWN, not the behavior.
+ */
+export function collectClassBehavior(vp: Record<string, unknown>, template: LayoutTemplate): ClassBehaviorRule[] {
+    const presets = template.presets?.includeClasses ?? {};
+    const resolved = resolveIncludeClasses(getProp(vp, 'includeClasses'), presets);
+    if (!resolved) return [];
+    const rules: ClassBehaviorRule[] = [];
+    for (const f of resolved) {
+        if (typeof f === 'string' || f.class === undefined) continue;
+        if (f.occludes === false || f.classify === false) {
+            rules.push({
+                class: f.class,
+                ...(f.occludes === false ? { occludes: false } : {}),
+                ...(f.classify === false ? { classify: false } : {})
+            });
+        }
+    }
+    return rules;
+}
+
+/**
+ * Filters products to the closure. Only products that can self-classify via `class.is`
+ * participate — adapter products without a class matcher always stay, because their raw
+ * class names may not use the friendly vocabulary templates speak (dropping them on a
+ * name mismatch would silently blank the sheet).
+ */
+export function filterProductsByClosure<TProduct extends { class?: { is(c: unknown): boolean } }>(
+    products: TProduct[],
+    closure: ReadonlySet<string>
+): TProduct[] {
+    return products.filter((p) => {
+        const is = p.class?.is;
+        if (typeof is !== 'function') return true;
+        for (const c of closure) {
+            if (p.class!.is(c)) return true;
+        }
+        return false;
+    });
+}

package/src/layout/clipUtils.ts

@@ -1,3 +1,4 @@
+import polygonClipping from 'polygon-clipping';
 import type { SvgModelView } from './types';
 import { EPSILON_DIVISION_SAFETY, CENTER_FRACTION } from './geometryConstants';
 
@@ -85,6 +86,43 @@ export const filterEntriesByClip = (
     });
 };
 
+/**
+ * Union polygons so overlapping ones merge into a single outline (disjoint
+ * polygons pass through unchanged). Used on expanded clip polygons — two
+ * adjacent clip targets whose expansions overlap should read as one region,
+ * not as outlines crossing through each other.
+ *
+ * The result is a flat ring list that may include hole rings (e.g. several
+ * regions enclosing a courtyard) — consumers rendering fills or clip paths
+ * from these rings must use even-odd semantics.
+ */
+export const unionPolygons = (polys: Polygon[]): Polygon[] => {
+    if (!Array.isArray(polys) || polys.length < 2) return polys ?? [];
+    try {
+        const input = polys
+            .filter((p) => p.length >= 3)
+            .map((p): [number, number][][] => [[...p.map((pt): [number, number] => [pt.x, pt.y]), [p[0].x, p[0].y]]]);
+        if (input.length < 2) return polys;
+        const result = polygonClipping.union(input[0], ...input.slice(1));
+        const rings: Polygon[] = [];
+        for (const poly of result) {
+            for (const ring of poly) {
+                const r: Polygon = ring.map(([x, y]) => ({ x, y }));
+                // Drop the duplicated closing point the library emits.
+                if (r.length > 1 && r[0].x === r[r.length - 1].x && r[0].y === r[r.length - 1].y) {
+                    r.pop();
+                }
+                if (r.length >= 3) rings.push(r);
+            }
+        }
+        return rings.length ? rings : polys;
+    } catch {
+        // Boolean ops can throw on degenerate input — fall back to the
+        // un-unioned polygons rather than losing the clip entirely.
+        return polys;
+    }
+};
+
 export const offsetPolygons = (polys: Polygon[], delta: number): Polygon[] => {
     if (!Array.isArray(polys) || !polys.length || !Number.isFinite(delta) || delta === 0) return polys ?? [];
     const intersectLines = (p: Point, r: Point, q: Point, s: Point): Point | null => {
@@ -93,19 +131,40 @@ export const offsetPolygons = (polys: Polygon[], delta: number): Polygon[] => {
         const t = ((q.x - p.x) * s.y - (q.y - p.y) * s.x) / rxs;
         return { x: p.x + t * r.x, y: p.y + t * r.y };
     };
+    // Vertices closer than this are treated as duplicates (coordinates are in
+    // model metres, so 0.1 mm is far below anything architectural).
+    const DUPLICATE_EPS = 1e-4;
     const offsetPoly = (poly: Polygon): Polygon => {
-        const n = poly.length;
+        // Sanitize the ring first: cut polylines usually repeat the first point
+        // as a closing point, and mesh cutting can emit consecutive
+        // near-duplicates. A zero-length edge has a zero normal, which
+        // degenerates the miter intersection and leaves that vertex unoffset —
+        // visible as a collapsed/distorted corner in the expanded outline.
+        const pts: Polygon = [];
+        for (const p of poly) {
+            const last = pts[pts.length - 1];
+            if (last && Math.abs(last.x - p.x) < DUPLICATE_EPS && Math.abs(last.y - p.y) < DUPLICATE_EPS) continue;
+            pts.push(p);
+        }
+        while (
+            pts.length > 1 &&
+            Math.abs(pts[0].x - pts[pts.length - 1].x) < DUPLICATE_EPS &&
+            Math.abs(pts[0].y - pts[pts.length - 1].y) < DUPLICATE_EPS
+        ) {
+            pts.pop();
+        }
+        const n = pts.length;
         if (n < 3) return poly;
-        const area = poly.reduce((sum, p, i) => {
-            const q = poly[(i + 1) % n];
+        const area = pts.reduce((sum, p, i) => {
+            const q = pts[(i + 1) % n];
             return sum + p.x * q.y - q.x * p.y;
         }, 0);
         const orient = area >= 0 ? 1 : -1; // ccw => outward is right normal
         const out: Polygon = [];
         for (let i = 0; i < n; i++) {
-            const p0 = poly[(i + n - 1) % n];
-            const p1 = poly[i];
-            const p2 = poly[(i + 1) % n];
+            const p0 = pts[(i + n - 1) % n];
+            const p1 = pts[i];
+            const p2 = pts[(i + 1) % n];
             const e1x = p1.x - p0.x;
             const e1y = p1.y - p0.y;
             const e2x = p2.x - p1.x;

package/src/layout/filters.ts

@@ -33,6 +33,29 @@ const matchesClass = (itemClass: unknown, classFilter: string | string[] | undef
     return classes.some((c) => classEquals(normalizeClass(c), normalized));
 };
 
+/**
+ * Check whether a *live* product's class matches a filter, with the same semantics extracted items
+ * get from {@link matchesClass}: case-insensitive, `Ifc` prefix optional, arrays mean any-of.
+ *
+ * Live products carry a `ModelProductClass` rather than a string, and its `is()` compares with
+ * `===`. That rejects `SPACE` and `IFCWALL` — values every other filter in the same template
+ * accepts — and its own `Ifc` handling is case-sensitive too (`'IFCWALL'.startsWith('Ifc')` is
+ * false). Comparing the class's own `id`/`type` through `matchesClass` keeps product selection
+ * identical to the rest of the template rather than subtly stricter.
+ */
+const matchesProductClass = (product: unknown, classFilter: string | string[] | undefined): boolean => {
+    if (classFilter === undefined) return true;
+    if (!isRecord(product)) return false;
+    const cls = getProp(product, 'class');
+    const id = isRecord(cls) ? getProp(cls, 'id') : undefined;
+    const type = isRecord(cls) ? getProp(cls, 'type') : undefined;
+    return (
+        matchesClass(id, classFilter) ||
+        matchesClass(type, classFilter) ||
+        matchesClass(getProp(product, 'className'), classFilter)
+    );
+};
+
 /**
  * Check whether an item matches a `where` condition.
  *
@@ -55,13 +78,13 @@ const matchesWhere = (item: unknown, where: WhereCondition | undefined): boolean
 };
 
 /**
- * V2 filter: match items by class + where conditions.
+ * Match items by class + where conditions.
  *
  * @param item - An object with ifcClass and propertySets
  * @param classFilter - IFC class name(s) to match, or undefined for any
  * @param where - Property conditions (short paths), or undefined for no conditions
  */
-export const matchesV2Filter = (
+const matchesFilterImpl = (
     item: unknown,
     classFilter: string | string[] | undefined,
     where: WhereCondition | undefined
@@ -77,4 +100,9 @@ export const matchesV2Filter = (
     return true;
 };
 
-export { normalizeClass, classEquals, normalizeValue, matchesClass, matchesWhere };
+export const matchesFilter = matchesFilterImpl;
+
+/** @deprecated Use {@link matchesFilter} — there never was a V1; the name was noise. */
+export const matchesV2Filter = matchesFilterImpl;
+
+export { normalizeClass, classEquals, normalizeValue, matchesClass, matchesProductClass, matchesWhere };