@ifc-lite/viewer 1.19.1 → 1.21.0

package/src/hooks/ids/idsDataAccessor.ts

@@ -3,271 +3,23 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 /**
- * IDS Data Accessor Factory
+ * IDS Data Accessor — thin wrapper around the canonical bridge.
  *
- * Creates an IFCDataAccessor bridge from an IfcDataStore to the IDS
- * validator's expected interface. This is a pure function with no
- * React dependencies.
+ * The actual `IfcDataStore → IFCDataAccessor` translation lives in
+ * `@ifc-lite/ids/bridge` so the viewer, the corpus-parity harness,
+ * and the MCP server share one implementation. Keeping this file as
+ * a re-export preserves the existing import path for callers that
+ * pass through `_modelId` (currently unused but preserved for API
+ * stability — the validator already takes a `modelInfo` separately).
  */
 
-import type {
-  IFCDataAccessor,
-  PropertyValueResult,
-  PropertySetInfo,
-  ClassificationInfo,
-  MaterialInfo,
-  ParentInfo,
-  PartOfRelation,
-} from '@ifc-lite/ids';
-import {
-  type IfcDataStore,
-  extractAllEntityAttributes,
-  extractTypeEntityOwnProperties,
-} from '@ifc-lite/parser';
+import type { IFCDataAccessor } from '@ifc-lite/ids';
+import { createDataAccessor as createBridgeAccessor } from '@ifc-lite/ids/bridge';
+import type { IfcDataStore } from '@ifc-lite/parser';
 
-/**
- * Create an IFCDataAccessor from an IfcDataStore
- * This bridges the viewer's data store to the IDS validator's interface
- */
 export function createDataAccessor(
   dataStore: IfcDataStore,
   _modelId: string
 ): IFCDataAccessor {
-  return {
-    getEntityType(expressId: number): string | undefined {
-      // Try entities table first
-      const entityType = dataStore.entities?.getTypeName?.(expressId);
-      if (entityType) return entityType;
-
-      // Fallback to entityIndex
-      const byId = dataStore.entityIndex?.byId;
-      if (byId) {
-        const entry = byId.get(expressId);
-        if (entry) {
-          return typeof entry === 'object' && 'type' in entry ? String(entry.type) : undefined;
-        }
-      }
-      return undefined;
-    },
-
-    getEntityName(expressId: number): string | undefined {
-      return dataStore.entities?.getName?.(expressId);
-    },
-
-    getGlobalId(expressId: number): string | undefined {
-      return dataStore.entities?.getGlobalId?.(expressId);
-    },
-
-    getDescription(expressId: number): string | undefined {
-      return dataStore.entities?.getDescription?.(expressId);
-    },
-
-    getObjectType(expressId: number): string | undefined {
-      // Try the pre-computed ObjectType first (works for IfcObject subtypes)
-      const objectType = dataStore.entities?.getObjectType?.(expressId);
-      if (objectType) return objectType;
-
-      // For IfcTypeObject subtypes (IfcWallType, etc.), ObjectType doesn't exist —
-      // we need to extract PredefinedType from entity attributes instead.
-      // Also handles IfcObject subtypes that have PredefinedType at different positions.
-      const allAttrs = extractAllEntityAttributes(dataStore, expressId);
-      const predefinedType = allAttrs.find(a => a.name === 'PredefinedType');
-      if (predefinedType?.value && predefinedType.value !== 'NOTDEFINED') {
-        return predefinedType.value;
-      }
-
-      // If PredefinedType is USERDEFINED or absent, check ObjectType from attributes
-      const objTypeAttr = allAttrs.find(a => a.name === 'ObjectType');
-      if (objTypeAttr?.value) {
-        return objTypeAttr.value;
-      }
-
-      return undefined;
-    },
-
-    getEntitiesByType(typeName: string): number[] {
-      const byType = dataStore.entityIndex?.byType;
-      if (byType) {
-        const ids = byType.get(typeName.toUpperCase());
-        if (ids) return Array.from(ids);
-      }
-      return [];
-    },
-
-    getAllEntityIds(): number[] {
-      const byId = dataStore.entityIndex?.byId;
-      if (byId) {
-        return Array.from(byId.keys());
-      }
-      return [];
-    },
-
-    getPropertyValue(
-      expressId: number,
-      propertySetName: string,
-      propertyName: string
-    ): PropertyValueResult | undefined {
-      const propertiesStore = dataStore.properties;
-      if (!propertiesStore) return undefined;
-
-      // Get property sets for this entity using getForEntity (returns PropertySet[])
-      const psets = propertiesStore.getForEntity?.(expressId);
-      if (!psets) return undefined;
-
-      for (const pset of psets) {
-        if (pset.name.toLowerCase() === propertySetName.toLowerCase()) {
-          const props = pset.properties || [];
-          for (const prop of props) {
-            if (prop.name.toLowerCase() === propertyName.toLowerCase()) {
-              // Convert value: ensure it's a primitive type (not array)
-              let value: string | number | boolean | null = null;
-              if (Array.isArray(prop.value)) {
-                // For arrays, convert to string representation
-                value = JSON.stringify(prop.value);
-              } else {
-                value = prop.value as string | number | boolean | null;
-              }
-              return {
-                value,
-                dataType: String(prop.type || 'IFCLABEL'),
-                propertySetName: pset.name,
-                propertyName: prop.name,
-              };
-            }
-          }
-        }
-      }
-      return undefined;
-    },
-
-    getPropertySets(expressId: number): PropertySetInfo[] {
-      const propertiesStore = dataStore.properties;
-
-      // Try relationship-based properties first (works for IfcObject instances)
-      const psets = propertiesStore?.getForEntity?.(expressId);
-
-      // Convert property sets to the IDS format
-      const mapPsets = (rawPsets: Array<{ name: string; properties: Array<{ name: string; value: unknown; type: unknown }> }>): PropertySetInfo[] =>
-        rawPsets.map((pset) => ({
-          name: pset.name,
-          properties: (pset.properties || []).map((prop) => {
-            let value: string | number | boolean | null = null;
-            if (Array.isArray(prop.value)) {
-              value = JSON.stringify(prop.value);
-            } else {
-              value = prop.value as string | number | boolean | null;
-            }
-            return {
-              name: prop.name,
-              value,
-              dataType: String(prop.type || 'IFCLABEL'),
-            };
-          }),
-        }));
-
-      if (psets && psets.length > 0) {
-        return mapPsets(psets);
-      }
-
-      // For IfcTypeObject subtypes (IfcWallType, IfcSlabType, etc.),
-      // properties come from the HasPropertySets attribute (index 5),
-      // not from IfcRelDefinesByProperties relationships.
-      const typePsets = extractTypeEntityOwnProperties(dataStore, expressId);
-      if (typePsets.length > 0) {
-        return mapPsets(typePsets);
-      }
-
-      return [];
-    },
-
-    getClassifications(expressId: number): ClassificationInfo[] {
-      // Classifications might be stored separately or in properties
-      // This is a placeholder - implement based on actual data structure
-      const classifications: ClassificationInfo[] = [];
-
-      // Check if there's a classifications accessor
-      const classStore = (dataStore as { classifications?: { getForEntity?: (id: number) => ClassificationInfo[] } }).classifications;
-      if (classStore?.getForEntity) {
-        return classStore.getForEntity(expressId);
-      }
-
-      return classifications;
-    },
-
-    getMaterials(expressId: number): MaterialInfo[] {
-      // Materials might be stored separately or in relationships
-      const materials: MaterialInfo[] = [];
-
-      // Check if there's a materials accessor
-      const matStore = (dataStore as { materials?: { getForEntity?: (id: number) => MaterialInfo[] } }).materials;
-      if (matStore?.getForEntity) {
-        return matStore.getForEntity(expressId);
-      }
-
-      return materials;
-    },
-
-    getParent(
-      expressId: number,
-      relationType: PartOfRelation
-    ): ParentInfo | undefined {
-      const relationships = dataStore.relationships;
-      if (!relationships) return undefined;
-
-      // Map IDS relation type to internal relation type
-      const relationMap: Record<PartOfRelation, string> = {
-        'IfcRelAggregates': 'Aggregates',
-        'IfcRelContainedInSpatialStructure': 'ContainedInSpatialStructure',
-        'IfcRelNests': 'Nests',
-        'IfcRelVoidsElement': 'VoidsElement',
-        'IfcRelFillsElement': 'FillsElement',
-      };
-
-      const relType = relationMap[relationType];
-      if (!relType) return undefined;
-
-      // Get related entities (parent direction)
-      const getRelated = relationships.getRelated;
-      if (getRelated) {
-        const parents = getRelated(expressId, relType as never, 'inverse');
-        if (parents && parents.length > 0) {
-          const parentId = parents[0];
-          return {
-            expressId: parentId,
-            entityType: this.getEntityType(parentId) || 'Unknown',
-            predefinedType: this.getObjectType(parentId),
-          };
-        }
-      }
-
-      return undefined;
-    },
-
-    getAttribute(expressId: number, attributeName: string): string | undefined {
-      const lowerName = attributeName.toLowerCase();
-
-      // Map common attribute names to accessor methods
-      switch (lowerName) {
-        case 'name':
-          return this.getEntityName(expressId);
-        case 'description':
-          return this.getDescription(expressId);
-        case 'globalid':
-          return this.getGlobalId(expressId);
-        case 'objecttype':
-        case 'predefinedtype':
-          return this.getObjectType(expressId);
-        default: {
-          // Try to get from entities table if available
-          const entities = dataStore.entities as {
-            getAttribute?: (id: number, attr: string) => string | undefined;
-          };
-          if (entities?.getAttribute) {
-            return entities.getAttribute(expressId, attributeName);
-          }
-          return undefined;
-        }
-      }
-    },
-  };
+  return createBridgeAccessor(dataStore);
 }

package/src/hooks/ingest/pointCloudIngest.ts

@@ -23,7 +23,7 @@ import type { IfcDataStore } from '@ifc-lite/parser';
 import type { SchemaVersion } from '../../store/types.js';
 import { createCoordinateInfo } from '../../utils/localParsingUtils.js';
 
-export type PointCloudFormat = 'las' | 'laz' | 'ply' | 'pcd' | 'e57';
+export type PointCloudFormat = 'las' | 'laz' | 'ply' | 'pcd' | 'e57' | 'pts' | 'xyz';
 
 /**
  * IfcTypeEnum.IfcGeographicElement — the closest IFC4 entity for a scan
@@ -182,27 +182,60 @@ export function detectPointCloudFormat(
   fileName: string,
   buffer: ArrayBuffer | null,
 ): PointCloudFormat | null {
-  const lower = fileName.toLowerCase();
-  if (lower.endsWith('.las')) return 'las';
-  if (lower.endsWith('.laz')) return 'laz';
-  if (lower.endsWith('.ply')) return 'ply';
-  if (lower.endsWith('.pcd')) return 'pcd';
-  if (lower.endsWith('.e57')) return 'e57';
+  // Magic bytes win over extension when both are available — a LAS
+  // file dropped as `*.ply` should still load as LAS, not be forced
+  // through the wrong decoder. PTS / XYZ are ASCII so they have no
+  // distinctive magic and stay extension-only at the bottom.
   if (buffer && buffer.byteLength >= 8) {
     const view = new DataView(buffer, 0, Math.min(buffer.byteLength, 32));
-    if (view.getUint32(0, true) === 0x4653414c) return 'las';
-    // ASCII probe — first three bytes "ply" → PLY; "# .P" or ".PCD" → PCD.
-    const b0 = view.getUint8(0), b1 = view.getUint8(1), b2 = view.getUint8(2);
-    if (b0 === 0x70 /* p */ && b1 === 0x6c /* l */ && b2 === 0x79 /* y */) return 'ply';
-    if (b0 === 0x23 /* # */ && view.byteLength > 4 && view.getUint8(2) === 0x2e /* . */) return 'pcd';
-    // E57 magic = "ASTM-E57" (8 bytes)
+    // E57 magic = "ASTM-E57" (8 bytes) — check before LAS so files
+    // can't accidentally match on the LAS magic in their first 4 bytes.
     if (
       view.getUint8(0) === 0x41 && view.getUint8(1) === 0x53
       && view.getUint8(2) === 0x54 && view.getUint8(3) === 0x4d
       && view.getUint8(4) === 0x2d && view.getUint8(5) === 0x45
       && view.getUint8(6) === 0x35 && view.getUint8(7) === 0x37
     ) return 'e57';
+    if (view.getUint32(0, true) === 0x4653414c /* "LASF" little-endian */) {
+      // LAS and LAZ share the LASF magic; differentiate by extension
+      // when available, otherwise default to LAS (laz-perf will throw
+      // a clear error on a non-LAZ payload).
+      const lower = fileName.toLowerCase();
+      if (lower.endsWith('.laz')) return 'laz';
+      return 'las';
+    }
+    // ASCII probes: "ply" header / PCD header line.
+    const b0 = view.getUint8(0), b1 = view.getUint8(1), b2 = view.getUint8(2);
+    if (b0 === 0x70 /* p */ && b1 === 0x6c /* l */ && b2 === 0x79 /* y */) return 'ply';
+    // PCDs in the wild use three header shapes:
+    //   1. `# .PCD v0.7\n…`              — original commented header
+    //   2. `VERSION 0.7\n…`              — version-first (PCL pcl_io)
+    //   3. `FIELDS x y z\n…`             — fields-first (some converters)
+    // Match all three so a renamed PCD doesn't fall through to the
+    // extension-based detector.
+    if (b0 === 0x23 /* # */ && view.byteLength > 4 && view.getUint8(2) === 0x2e /* . */) return 'pcd';
+    if (
+      b0 === 0x56 /* V */ && b1 === 0x45 /* E */ && b2 === 0x52 /* R */
+      && view.byteLength > 7 && view.getUint8(3) === 0x53 /* S */
+      && view.getUint8(4) === 0x49 /* I */ && view.getUint8(5) === 0x4f /* O */
+      && view.getUint8(6) === 0x4e /* N */
+    ) return 'pcd';
+    if (
+      b0 === 0x46 /* F */ && b1 === 0x49 /* I */ && b2 === 0x45 /* E */
+      && view.byteLength > 6 && view.getUint8(3) === 0x4c /* L */
+      && view.getUint8(4) === 0x44 /* D */ && view.getUint8(5) === 0x53 /* S */
+    ) return 'pcd';
   }
+  // Fall back to extension when the buffer is missing / too short
+  // OR for ASCII formats (PTS / XYZ) that don't carry a magic header.
+  const lower = fileName.toLowerCase();
+  if (lower.endsWith('.las')) return 'las';
+  if (lower.endsWith('.laz')) return 'laz';
+  if (lower.endsWith('.ply')) return 'ply';
+  if (lower.endsWith('.pcd')) return 'pcd';
+  if (lower.endsWith('.e57')) return 'e57';
+  if (lower.endsWith('.pts')) return 'pts';
+  if (lower.endsWith('.xyz')) return 'xyz';
   return null;
 }
 
@@ -228,9 +261,6 @@ export function describeUnsupportedFormat(fileName: string): string | null {
   if (lower.endsWith('.fls') || lower.endsWith('.lsproj')) {
     return 'Faro Scene project — export to E57 from Scene to load it here.';
   }
-  if (lower.endsWith('.pts') || lower.endsWith('.xyz')) {
-    return 'PTS / XYZ ASCII points — not yet supported (export to PLY or LAS).';
-  }
   return null;
 }
 
@@ -243,6 +273,76 @@ export function describeUnsupportedFormat(fileName: string): string | null {
  */
 let nextSyntheticExpressId = 1;
 
+/**
+ * Counter shared across all in-flight ingests. We log up to
+ * `DEBUG_CLASS_LOG_LIMIT` chunks total per page session — enough to
+ * see whether the first scan's classifications are reaching the
+ * renderer without spamming the console for users with many files.
+ *
+ * Reset to zero on a hot module reload (HMR re-evaluates the module),
+ * so the dev workflow is "load file → see ≤ 3 chunk diagnostics".
+ */
+const DEBUG_CLASS_LOG_LIMIT = 3;
+let debugClassChunkLogs = 0;
+
+/**
+ * Log presence + 16-bin histogram of the chunk's classification IDs.
+ * Used to debug "classification colour mode shows everything as
+ * unclassified". Common causes the histogram surfaces immediately:
+ *   - chunk.classifications is undefined → format / decoder didn't
+ *     emit it (look at the format's streaming source).
+ *   - All values 0 or 1 → file is genuinely unclassified (LAS spec
+ *     classes 0 = "Created, never classified", 1 = "Unclassified");
+ *     not a viewer bug.
+ *   - Non-trivial spread but rendering is grey → packing or shader
+ *     read is wrong.
+ */
+function logChunkClassHistogram(
+  fileName: string,
+  format: PointCloudFormat,
+  chunk: DecodedPointChunk,
+): void {
+  const classes = chunk.classifications;
+  if (!classes) {
+    // E57 has no standard classification field per ASTM E2807, so
+    // most scans (Faro Focus, Leica BLK, Trimble) won't carry one.
+    // A non-standard `classification` prototype field IS now read
+    // when present; absence here means the file genuinely doesn't
+    // include per-point class IDs.
+    const hint = format === 'e57'
+      ? ' (E57 spec doesn\'t define classification — file must be from CloudCompare or a custom LIDAR pipeline to have it)'
+      : ' (decoder didn\'t emit any per-point class IDs)';
+    console.log(
+      `[pointcloud-debug] ${format} ${fileName} chunk #${debugClassChunkLogs}: `
+      + `pointCount=${chunk.pointCount} classifications=undefined${hint}`,
+    );
+    return;
+  }
+  // 32-wide histogram (covers the ASPRS LAS 1.4 standard range).
+  // Anything past 31 lands in `overflow` so misclassified high
+  // values still surface.
+  const hist = new Uint32Array(32);
+  let overflow = 0;
+  let sample: number[] = [];
+  const n = Math.min(classes.length, chunk.pointCount);
+  for (let i = 0; i < n; i++) {
+    const c = classes[i];
+    if (c < 32) hist[c]++;
+    else overflow++;
+    if (sample.length < 8) sample.push(c);
+  }
+  const nonZero: string[] = [];
+  for (let c = 0; c < 32; c++) {
+    if (hist[c] > 0) nonZero.push(`${c}=${hist[c]}`);
+  }
+  if (overflow > 0) nonZero.push(`>31:${overflow}`);
+  console.log(
+    `[pointcloud-debug] ${format} ${fileName} chunk #${debugClassChunkLogs}: `
+    + `pointCount=${chunk.pointCount} classes.length=${classes.length} `
+    + `first8=[${sample.join(',')}] hist={${nonZero.join(', ')}}`,
+  );
+}
+
 /**
  * Stream a point cloud into the renderer. Returns immediately; await
  * `result.done` for completion.
@@ -284,6 +384,17 @@ export function ingestPointCloud(opts: PointCloudIngestOptions): PointCloudInges
         });
       },
       onChunk: (chunk) => {
+        // Per-chunk classification diagnostic. Logs whether the
+        // chunk carries a classifications buffer and a 16-bin class
+        // histogram for the first few chunks of each stream so it's
+        // easy to see whether the source actually carries class IDs
+        // (LAS files often have everything as 0/1 for "unclassified").
+        // Capped at 3 logs per stream to keep the console readable;
+        // further debug-on-demand can be done from devtools.
+        if (debugClassChunkLogs < DEBUG_CLASS_LOG_LIMIT) {
+          debugClassChunkLogs++;
+          logChunkClassHistogram(opts.fileName, opts.format, chunk);
+        }
         // LAS / LAZ / E57 / typical scan-style PLY + PCD all store data
         // Z-up by convention (LIDAR / surveying tradition). The renderer
         // is Y-up internally — the IFCx ingest path applies the same

package/src/hooks/useDrawingGeneration.ts

@@ -23,6 +23,7 @@ import {
   type SectionConfig,
 } from '@ifc-lite/drawing-2d';
 import { GeometryProcessor, type GeometryResult } from '@ifc-lite/geometry';
+import { customPlaneCenter } from '@/store';
 
 // Axis conversion from semantic (down/front/side) to geometric (x/y/z)
 export const AXIS_MAP: Record<'down' | 'front' | 'side', 'x' | 'y' | 'z'> = {
@@ -34,7 +35,24 @@ export const AXIS_MAP: Record<'down' | 'front' | 'side', 'x' | 'y' | 'z'> = {
 interface UseDrawingGenerationParams {
   geometryResult: GeometryResult | null | undefined;
   ifcDataStore: { source: Uint8Array } | null;
-  sectionPlane: { axis: 'down' | 'front' | 'side'; position: number; flipped: boolean };
+  /**
+   * Section plane state. `custom` is the optional face-pick override
+   * (issue #243); when set the cutter cuts on that arbitrary plane and
+   * the cap basis flows from `custom.tangent`/`bitangent` so the cap
+   * silhouette lands precisely on the tilted plane.
+   */
+  sectionPlane: {
+    axis: 'down' | 'front' | 'side';
+    position: number;
+    flipped: boolean;
+    custom?: {
+      normal:    [number, number, number];
+      distance:  number;
+      pickedAt:  [number, number, number];
+      tangent:   [number, number, number];
+      bitangent: [number, number, number];
+    };
+  };
   displayOptions: { showHiddenLines: boolean; useSymbolicRepresentations: boolean; show3DOverlay: boolean; scale: number };
   combinedHiddenIds: Set<number>;
   combinedIsolatedIds: Set<number> | null;
@@ -275,6 +293,31 @@ export function useDrawingGeneration({
       // Override the flipped setting
       config.plane.flipped = sectionPlane.flipped;
 
+      // Face-pick custom plane (issue #243): hand the cutter the explicit
+      // basis so its 2D output sits in the same coordinate system the cap
+      // shader will lift back to 3D — without this the polygon and the
+      // shader-clipped silhouette would disagree on every non-cardinal
+      // pick (PR #581's bug).
+      if (sectionPlane.custom) {
+        const c = sectionPlane.custom;
+        // Use the LIVE plane anchor (pickedAt projected onto the current
+        // plane), not pickedAt itself. As the user drags the gizmo only
+        // `distance` changes — pickedAt sits off the live plane, and
+        // using it as the basis origin makes the round-trip lift drop
+        // the normal-component, freezing the cap polygons at the
+        // original pick location while the geometry clip slides. Using
+        // the projected center keeps the basis origin ON the live plane
+        // so the cutter's 2D points lift back to the actual cut surface.
+        const origin = customPlaneCenter(c);
+        config.plane.customPlane = {
+          normal:    { x: c.normal[0],   y: c.normal[1],   z: c.normal[2]   },
+          distance:  c.distance,
+          origin:    { x: origin[0],     y: origin[1],     z: origin[2]     },
+          tangent:   { x: c.tangent[0],  y: c.tangent[1],  z: c.tangent[2]  },
+          bitangent: { x: c.bitangent[0], y: c.bitangent[1], z: c.bitangent[2] },
+        };
+      }
+
       // Filter meshes by visibility (respect 3D hiding/isolation)
       let meshesToProcess = geometryResult.meshes;
 
@@ -553,9 +596,26 @@ export function useDrawingGeneration({
   // Auto-regenerate when section plane changes
   // Strategy: INSTANT - no debounce, but prevent overlapping computations
   // The generation time itself acts as natural batching for fast slider movements
-  const sectionRef = useRef({ axis: sectionPlane.axis, position: sectionPlane.position, flipped: sectionPlane.flipped });
+  //
+  // For face-picked custom planes (issue #243), `customKey` collapses the
+  // plane's normal+distance into a string we can compare cheaply — without
+  // it dragging the gizmo wouldn't trigger regeneration because the
+  // cardinal axis/position/flipped triple stays the same.
+  const customKey = (sp: { custom?: { normal: [number, number, number]; distance: number } }) =>
+    sp.custom ? `${sp.custom.normal.join(',')}|${sp.custom.distance}` : '';
+  const sectionRef = useRef({
+    axis: sectionPlane.axis,
+    position: sectionPlane.position,
+    flipped: sectionPlane.flipped,
+    customKey: customKey(sectionPlane),
+  });
   const isGeneratingRef = useRef(false);
-  const latestSectionRef = useRef({ axis: sectionPlane.axis, position: sectionPlane.position, flipped: sectionPlane.flipped });
+  const latestSectionRef = useRef({
+    axis: sectionPlane.axis,
+    position: sectionPlane.position,
+    flipped: sectionPlane.flipped,
+    customKey: customKey(sectionPlane),
+  });
   const [isRegenerating, setIsRegenerating] = useState(false);
 
   // Stable regenerate function that handles overlapping calls
@@ -583,7 +643,8 @@ export function useDrawingGeneration({
       if (
         current.axis !== targetSection.axis ||
         current.position !== targetSection.position ||
-        current.flipped !== targetSection.flipped
+        current.flipped !== targetSection.flipped ||
+        current.customKey !== targetSection.customKey
       ) {
         // Position changed during generation - regenerate immediately with latest
         // Use microtask to avoid blocking
@@ -592,22 +653,34 @@ export function useDrawingGeneration({
     }
   }, [generateDrawing]);
 
+  const customKeyValue = customKey(sectionPlane);
   useEffect(() => {
     // Always update latest section ref (even if generating)
-    latestSectionRef.current = { axis: sectionPlane.axis, position: sectionPlane.position, flipped: sectionPlane.flipped };
+    latestSectionRef.current = {
+      axis: sectionPlane.axis,
+      position: sectionPlane.position,
+      flipped: sectionPlane.flipped,
+      customKey: customKeyValue,
+    };
 
     // Check if section plane actually changed from last processed
     const prev = sectionRef.current;
     if (
       prev.axis === sectionPlane.axis &&
       prev.position === sectionPlane.position &&
-      prev.flipped === sectionPlane.flipped
+      prev.flipped === sectionPlane.flipped &&
+      prev.customKey === customKeyValue
     ) {
       return;
     }
 
     // Update processed ref
-    sectionRef.current = { axis: sectionPlane.axis, position: sectionPlane.position, flipped: sectionPlane.flipped };
+    sectionRef.current = {
+      axis: sectionPlane.axis,
+      position: sectionPlane.position,
+      flipped: sectionPlane.flipped,
+      customKey: customKeyValue,
+    };
 
     // If panel is visible OR 3D overlay is enabled, and we have geometry, regenerate INSTANTLY
     if ((panelVisible || displayOptions.show3DOverlay) && geometryResult?.meshes) {
@@ -615,7 +688,7 @@ export function useDrawingGeneration({
       // doRegenerate handles preventing overlaps and will auto-regenerate with latest when done
       doRegenerate();
     }
-  }, [panelVisible, displayOptions.show3DOverlay, sectionPlane.axis, sectionPlane.position, sectionPlane.flipped, geometryResult, combinedHiddenIds, combinedIsolatedIds, computedIsolatedIds, doRegenerate]);
+  }, [panelVisible, displayOptions.show3DOverlay, sectionPlane.axis, sectionPlane.position, sectionPlane.flipped, customKeyValue, geometryResult, combinedHiddenIds, combinedIsolatedIds, computedIsolatedIds, doRegenerate]);
 
   return {
     generateDrawing,