Resolve auto-hole edge selections

Point-and-click selection can land on either a generated auto-hole region segment or the original sketch segment that produced it. The generated segment has the sweep and adjacency data needed for edge tagging, while the original sketch segment may not.

Teach artifact graph selection helpers to resolve inner region paths through outerPathId, and to follow originalSegId mappings from source sketch segments to generated region segments for sweep and common-face lookup.

Cover the direct inner-path selection case plus source-segment sweep and common-face resolution.

Author: Irev-Dev

src/lang/std/artifactGraph.test.ts

@@ -2,6 +2,7 @@ import {
   type Artifact,
   coerceSelectionsToBody,
   getBodiesFromArtifactGraph,
+  getCommonFacesForEdge,
   getSketchBlockForArtifact,
   getSweepArtifactFromSelection,
   isFaceFromLegacySketch,
@@ -10,6 +11,62 @@ import type { ArtifactGraph, PathToNode } from '@src/lang/wasm'
 import type { Selection, Selections } from '@src/machines/modelingSharedTypes'
 import { describe, expect, it } from 'vitest'
 
+const codeRef = {
+  range: [0, 0, 0] as [number, number, number],
+  pathToNode: [],
+  nodePath: { steps: [] },
+}
+
+function addArtifacts(artifactGraph: ArtifactGraph, artifacts: Artifact[]) {
+  for (const artifact of artifacts) {
+    artifactGraph.set(artifact.id, artifact)
+  }
+}
+
+function pathArtifact(
+  overrides: Partial<Extract<Artifact, { type: 'path' }>> &
+    Pick<Extract<Artifact, { type: 'path' }>, 'id'>
+): Extract<Artifact, { type: 'path' }> {
+  return {
+    type: 'path',
+    subType: 'region',
+    codeRef,
+    planeId: 'plane-1',
+    segIds: [],
+    trajectorySweepId: null,
+    consumed: true,
+    ...overrides,
+  }
+}
+
+function segmentArtifact(
+  overrides: Partial<Extract<Artifact, { type: 'segment' }>> &
+    Pick<Extract<Artifact, { type: 'segment' }>, 'id' | 'pathId'>
+): Extract<Artifact, { type: 'segment' }> {
+  return {
+    type: 'segment',
+    edgeIds: [],
+    commonSurfaceIds: [],
+    codeRef,
+    ...overrides,
+  }
+}
+
+function sweepArtifact(pathId: string): Extract<Artifact, { type: 'sweep' }> {
+  return {
+    type: 'sweep',
+    id: 'sweep-1',
+    codeRef,
+    pathId,
+    subType: 'extrusion',
+    surfaceIds: [],
+    edgeIds: [],
+    method: 'merge',
+    trajectoryId: null,
+    consumed: false,
+  }
+}
+
 describe('getSweepArtifactFromSelection', () => {
   it('should return sweep from edgeCut -> segment selection', () => {
     const artifactGraph: ArtifactGraph = new Map()
@@ -150,6 +207,135 @@ describe('getSweepArtifactFromSelection', () => {
       expect(result.id).toBe('sweep-1')
     }
   })
+
+  it('should return sweep from segment on inner region path', () => {
+    const artifactGraph: ArtifactGraph = new Map()
+    const segment = segmentArtifact({
+      id: 'inner-segment',
+      pathId: 'inner-path',
+    })
+    addArtifacts(artifactGraph, [
+      pathArtifact({
+        id: 'outer-path',
+        segIds: ['outer-segment'],
+        sweepId: 'sweep-1',
+        innerPathId: 'inner-path',
+      }),
+      pathArtifact({
+        id: 'inner-path',
+        segIds: ['inner-segment'],
+        outerPathId: 'outer-path',
+      }),
+      sweepArtifact('outer-path'),
+      segment,
+    ])
+
+    const selection: Selection = {
+      artifact: segment,
+      codeRef: { range: [0, 0, 0], pathToNode: [] },
+    }
+
+    const result = getSweepArtifactFromSelection(selection, artifactGraph)
+
+    expect(result).not.toBeInstanceOf(Error)
+    if (!(result instanceof Error)) {
+      expect(result.id).toBe('sweep-1')
+    }
+  })
+
+  it('should return sweep from source segment mapped to an inner region path segment', () => {
+    const artifactGraph: ArtifactGraph = new Map()
+    const sourceSegment = segmentArtifact({
+      id: 'source-segment',
+      pathId: 'source-path',
+    })
+    addArtifacts(artifactGraph, [
+      pathArtifact({
+        id: 'source-path',
+        subType: 'sketch',
+        segIds: ['source-segment'],
+      }),
+      sourceSegment,
+      pathArtifact({
+        id: 'outer-path',
+        segIds: ['outer-segment'],
+        sweepId: 'sweep-1',
+        originPathId: 'source-path',
+        innerPathId: 'inner-path',
+      }),
+      pathArtifact({
+        id: 'inner-path',
+        segIds: ['inner-segment'],
+        originPathId: 'source-path',
+        outerPathId: 'outer-path',
+      }),
+      sweepArtifact('outer-path'),
+      segmentArtifact({
+        id: 'inner-segment',
+        pathId: 'inner-path',
+        originalSegId: 'source-segment',
+      }),
+    ])
+
+    const result = getSweepArtifactFromSelection(
+      {
+        artifact: sourceSegment,
+        codeRef: { range: [0, 0, 0], pathToNode: [] },
+      },
+      artifactGraph
+    )
+
+    expect(result).not.toBeInstanceOf(Error)
+    if (!(result instanceof Error)) {
+      expect(result.id).toBe('sweep-1')
+    }
+  })
+})
+
+describe('getCommonFacesForEdge', () => {
+  it('should return common faces from a generated region segment mapped to a source segment', () => {
+    const artifactGraph: ArtifactGraph = new Map()
+    const sourceSegment = segmentArtifact({
+      id: 'source-segment',
+      pathId: 'source-path',
+    })
+    addArtifacts(artifactGraph, [
+      sourceSegment,
+      segmentArtifact({
+        id: 'inner-segment',
+        pathId: 'inner-path',
+        originalSegId: 'source-segment',
+        commonSurfaceIds: ['wall-1', 'cap-1'],
+      }),
+      {
+        type: 'wall',
+        id: 'wall-1',
+        segId: 'inner-segment',
+        sweepId: 'sweep-1',
+        pathIds: [],
+        edgeCutEdgeIds: [],
+        cmdId: 'cmd-1',
+        faceCodeRef: codeRef,
+      },
+      {
+        type: 'cap',
+        id: 'cap-1',
+        subType: 'end',
+        sweepId: 'sweep-1',
+        pathIds: [],
+        edgeCutEdgeIds: [],
+        cmdId: 'cmd-1',
+        faceCodeRef: codeRef,
+      },
+    ])
+
+    const result = getCommonFacesForEdge(sourceSegment, artifactGraph)
+
+    expect(result).not.toBeInstanceOf(Error)
+    if (!(result instanceof Error)) {
+      expect(result.map(({ id }) => id).sort()).toEqual(['cap-1', 'wall-1'])
+    }
+  })
 })
 
 describe('coerceSelectionsToBody', () => {

src/lang/std/artifactGraph.ts

@@ -137,6 +137,59 @@ export function getArtifactOfTypes<T extends Artifact['type'][]>(
   return artifact as Extract<Artifact, { type: T[number] }>
 }
 
+function getSweepFromPath(
+  path: PathArtifact,
+  artifactGraph: ArtifactGraph
+): SweepArtifact | Error {
+  if (path.sweepId) {
+    return getArtifactOfTypes(
+      { key: path.sweepId, types: ['sweep'] },
+      artifactGraph
+    )
+  }
+
+  if (path.outerPathId) {
+    const outerPath = getArtifactOfTypes(
+      { key: path.outerPathId, types: ['path'] },
+      artifactGraph
+    )
+    if (err(outerPath)) return outerPath
+    return getSweepFromPath(outerPath, artifactGraph)
+  }
+
+  return new Error('Path does not have a sweepId')
+}
+
+function getMappedRegionSegments(
+  segment: SegmentArtifact,
+  artifactGraph: ArtifactGraph
+): SegmentArtifact[] {
+  return [...artifactGraph.values()].filter(
+    (artifact): artifact is SegmentArtifact =>
+      artifact.type === 'segment' &&
+      artifact.originalSegId === segment.id &&
+      artifact.id !== segment.id
+  )
+}
+
+function getSweepFromMappedRegionSegment(
+  segment: SegmentArtifact,
+  artifactGraph: ArtifactGraph
+): SweepArtifact | Error {
+  for (const mappedSegment of getMappedRegionSegments(segment, artifactGraph)) {
+    const path = getArtifactOfTypes(
+      { key: mappedSegment.pathId, types: ['path'] },
+      artifactGraph
+    )
+    if (path instanceof Error) continue
+
+    const sweep = getSweepFromPath(path, artifactGraph)
+    if (!(sweep instanceof Error)) return sweep
+  }
+
+  return new Error('Path does not have a sweepId')
+}
+
 export function getPatternArtifactForCopyId(
   id: ArtifactId,
   artifactGraph: ArtifactGraph
@@ -333,11 +386,7 @@ export function getSweepFromSuspectedSweepSurface(
       artifactGraph
     )
     if (err(path)) return path
-    if (!path.sweepId) return new Error('Path does not have a sweepId')
-    return getArtifactOfTypes(
-      { key: path.sweepId, types: ['sweep'] },
-      artifactGraph
-    )
+    return getSweepFromPath(path, artifactGraph)
   }
   return getArtifactOfTypes(
     { key: segOrEdge.sweepId, types: ['sweep'] },
@@ -349,13 +398,21 @@ export function getCommonFacesForEdge(
   artifact: SweepEdge | SegmentArtifact,
   artifactGraph: ArtifactGraph
 ): Extract<Artifact, { type: 'wall' | 'cap' }>[] | Error {
-  const faces = getArtifactsOfTypes(
-    { keys: artifact.commonSurfaceIds, types: ['wall', 'cap'] },
-    artifactGraph
-  )
-  if (err(faces)) return faces
-  if (faces.size === 0) return new Error('No common face found')
-  return [...faces.values()]
+  const edgeArtifacts =
+    artifact.type === 'segment'
+      ? [artifact, ...getMappedRegionSegments(artifact, artifactGraph)]
+      : [artifact]
+
+  for (const edgeArtifact of edgeArtifacts) {
+    const faces = getArtifactsOfTypes(
+      { keys: edgeArtifact.commonSurfaceIds, types: ['wall', 'cap'] },
+      artifactGraph
+    )
+    if (err(faces)) return faces
+    if (faces.size > 0) return [...faces.values()]
+  }
+
+  return new Error('No common face found')
 }
 
 export function getSweepArtifactFromSelection(
@@ -376,13 +433,17 @@ export function getSweepArtifactFromSelection(
       artifactGraph
     )
     if (err(_pathArtifact)) return _pathArtifact
-    if (!_pathArtifact.sweepId) return new Error('Path does not have a sweepId')
-    const _artifact = getArtifactOfTypes(
-      { key: _pathArtifact.sweepId, types: ['sweep'] },
-      artifactGraph
-    )
-    if (err(_artifact)) return _artifact
-    sweepArtifact = _artifact
+    const _artifact = getSweepFromPath(_pathArtifact, artifactGraph)
+    if (_artifact instanceof Error) {
+      const mappedSweep = getSweepFromMappedRegionSegment(
+        selection.artifact,
+        artifactGraph
+      )
+      if (mappedSweep instanceof Error) return _artifact
+      sweepArtifact = mappedSweep
+    } else {
+      sweepArtifact = _artifact
+    }
   } else if (
     selection.artifact?.type === 'cap' ||
     selection.artifact?.type === 'wall'