@bitmagic/cli 0.1.66-dev.6 → 0.1.66-dev.8

package/assets/character-skin-authoring/scripts/assemble_character.py

@@ -0,0 +1,205 @@
+"""Attach the shared body rig without re-exporting authored materials or eye layers.
+
+Original surface vertices match the dense bound mesh. Newly clipped eye vertices
+use a unanimous rigid-head field or exact bound-triangle interpolation. Optical
+rest fitting retains its pre-fit correspondence; off-surface evidence is rejected.
+"""
+import argparse,copy,hashlib,json,shutil
+from pathlib import Path
+import numpy as np
+from scipy.spatial import cKDTree
+from scipy.spatial.transform import Rotation
+from glb_arrays import read,accessor
+from glb_output import append_accessor
+from vision_materials import source_world_points
+from eye_assets import write_glb
+
+from workspace_paths import workspace_root
+ROOT=workspace_root(__file__)
+
+def node_matrix(node):
+    if 'matrix' in node:return np.asarray(node['matrix']).reshape(4,4).T
+    matrix=np.eye(4);matrix[:3,:3]=Rotation.from_quat(node.get('rotation',[0,0,0,1])).as_matrix()@np.diag(node.get('scale',[1,1,1]));matrix[:3,3]=node.get('translation',[0,0,0]);return matrix
+
+def world_matrices(doc):
+    parents={child:i for i,n in enumerate(doc['nodes']) for child in n.get('children',[])};cache={}
+    def world(i):
+        if i not in cache:cache[i]=(world(parents[i]) if i in parents else np.eye(4))@node_matrix(doc['nodes'][i])
+        return cache[i]
+    return [world(i) for i in range(len(doc['nodes']))]
+
+def set_transform(node,matrix):
+    scale=np.linalg.norm(matrix[:3,:3],axis=0);rotation=matrix[:3,:3]/scale
+    if not np.allclose(rotation.T@rotation,np.eye(3),atol=1e-5) or np.linalg.det(rotation)<0:raise ValueError('Eye attachment requires a non-sheared positive transform')
+    node.pop('matrix',None);node.update(translation=matrix[:3,3].tolist(),rotation=Rotation.from_matrix(rotation).as_quat().tolist(),scale=scale.tolist())
+
+def skin_points(points,joints,weights,matrices):
+    result=np.zeros_like(points,dtype=float);p=np.c_[points,np.ones(len(points))]
+    for slot in range(4):result+=np.einsum('nij,nj->ni',matrices[joints[:,slot]],p)[:,:3]*weights[:,slot,None]
+    return result
+
+def surface_weight_transfer(query,points,faces,joints,weights,tolerance):
+    """Exact closest-triangle interpolation; reject points off the bound surface."""
+    triangles=points[faces];centers=triangles.mean(1)
+    radius=np.linalg.norm(triangles-centers[:,None,:],axis=2).max()
+    tree=cKDTree(centers);vertices=cKDTree(points[np.unique(faces)])
+    result_j=[];result_w=[]
+    for point in query:
+        upper=vertices.query(point)[0]
+        ids=tree.query_ball_point(point,float(upper+radius+tolerance))
+        tri=triangles[ids];a=tri[:,0];u=tri[:,1]-a;v=tri[:,2]-a;p=point-a
+        uu=(u*u).sum(1);uv=(u*v).sum(1);vv=(v*v).sum(1);pu=(p*u).sum(1);pv=(p*v).sum(1)
+        determinant=uu*vv-uv*uv;safe=np.where(determinant>1e-24,determinant,1)
+        b=(vv*pu-uv*pv)/safe;c=(uu*pv-uv*pu)/safe
+        bary=np.stack([1-b-c,b,c],1);inside=(bary>=0).all(1)&(determinant>1e-24)
+        distance=np.linalg.norm(np.einsum('ni,nij->nj',bary,tri)-point,axis=1)
+        distance[~inside]=np.inf
+        for first,last in [(0,1),(1,2),(2,0)]:
+            edge=tri[:,last]-tri[:,first];length=(edge*edge).sum(1)
+            t=np.clip(((point-tri[:,first])*edge).sum(1)/np.maximum(length,1e-24),0,1)
+            candidate=np.linalg.norm(tri[:,first]+edge*t[:,None]-point,axis=1);better=candidate<distance
+            distance[better]=candidate[better];bary[better]=0;bary[better,first]=1-t[better];bary[better,last]=t[better]
+        closest=int(np.argmin(distance))
+        if distance[closest]>tolerance:raise ValueError('Binding provenance is not on the validated source surface')
+        corners=faces[ids[closest]];combined={}
+        for vertex,factor in zip(corners,bary[closest]):
+            for joint,weight in zip(joints[vertex],weights[vertex]):combined[int(joint)]=combined.get(int(joint),0)+float(factor*weight)
+        strongest=sorted(combined.items(),key=lambda item:item[1],reverse=True)[:4]
+        strongest += [(0,0)]*(4-len(strongest));total=sum(w for _,w in strongest)
+        if total<=0:raise ValueError('Bound triangle has no skin weights')
+        result_j.append([j for j,_ in strongest]);result_w.append([w/total for _,w in strongest])
+    return np.asarray(result_j),np.asarray(result_w)
+
+def assemble(sid,relative_input,variant='eyes'):
+    base=ROOT/'characters'/sid/'high/v1';input_path=(base/relative_input).resolve()
+    if base.resolve() not in input_path.parents:raise ValueError('Input must be a revision inside this character')
+    doc,data=read(input_path);rig_path=base/'output/character.glb';rig,rig_data=read(rig_path);rig_report=json.loads((base/'rig-report.json').read_text())
+    if hashlib.sha256(rig_path.read_bytes()).hexdigest()!=rig_report['output_sha256']:raise ValueError('Body rig changed after validation')
+    if rig_report['geometry_displacement_max_m']>1e-6:raise ValueError('Reshaped sources require an explicit surface deformation transfer')
+    if len(rig.get('skins',[]))!=1 or doc.get('skins'):raise ValueError('This assembly adapter adds exactly one new body skin')
+    body_node=next(i for i,n in enumerate(doc['nodes']) if n.get('mesh')==0)
+    rig_body=next(i for i,n in enumerate(rig['nodes']) if n.get('skin')==0)
+    if any('mesh' in n for i,n in enumerate(rig['nodes']) if i!=rig_body):raise ValueError('Unexpected extra body geometry')
+    worlds=world_matrices(doc);rig_world=world_matrices(rig)
+    if not np.allclose(rig_world[rig_body],np.eye(4),atol=1e-6):raise ValueError('Bound mesh needs an explicit nonidentity bind-space adapter')
+    primitives=doc['meshes'][0]['primitives'];positions=accessor(doc,data,primitives[0]['attributes']['POSITION'])
+    if any(p['attributes']['POSITION']!=primitives[0]['attributes']['POSITION'] for p in primitives):raise ValueError('Expected a shared surface vertex pool')
+    rp=rig['meshes'][rig['nodes'][rig_body]['mesh']]['primitives'][0]
+    bound_positions=accessor(rig,rig_data,rp['attributes']['POSITION']);bound_joints=accessor(rig,rig_data,rp['attributes']['JOINTS_0']).astype(np.int32);bound_weights=accessor(rig,rig_data,rp['attributes']['WEIGHTS_0'])
+    if not np.issubdtype(bound_weights.dtype,np.floating):raise ValueError('Decode normalized integer weight attributes explicitly')
+    scale=rig_report['normalization']['scale'];center=np.asarray(rig_report['normalization']['center']);normalization=np.eye(4);normalization[:3,:3]*=scale;normalization[:3,3]=-center[[0,2,1]]*np.array([1,1,-1])*scale
+    transform=normalization@worlds[body_node];expected=positions@transform[:3,:3].T+transform[:3,3]
+    binding_index=primitives[0]['attributes'].get('_BIND_SOURCE_POSITION')
+    if any(p['attributes'].get('_BIND_SOURCE_POSITION')!=binding_index for p in primitives):raise ValueError('Expected shared source binding positions across material partitions')
+    binding_positions=positions if binding_index is None else accessor(doc,data,binding_index)
+    if binding_positions.shape!=positions.shape or not np.isfinite(binding_positions).all():raise ValueError('Invalid source binding positions')
+    binding_expected=binding_positions@transform[:3,:3].T+transform[:3,3]
+    distance,index=cKDTree(bound_positions).query(binding_expected);tolerance=max(np.ptp(bound_positions,axis=0))*2e-6
+    joints=bound_joints[index].copy();weights=bound_weights[index].copy();unmatched=distance>tolerance
+    source_skin=rig['skins'][0];head_indices=[k for k,i in enumerate(source_skin['joints']) if rig['nodes'][i].get('name') in ['Head','mixamorigHead','mixamorig:Head']]
+    if len(head_indices)!=1:raise ValueError('The shared rig must identify one Head joint')
+    head=head_indices[0]
+    barycentric_count=0
+    if unmatched.any():
+        # A clipped ocular vertex is safe only within the explicit rigid-head field.
+        d,near=cKDTree(bound_positions).query(binding_expected[unmatched],k=4)
+        head_weight=np.sum(bound_weights[near]*(bound_joints[near]==head),axis=2)
+        rigid=(d<=.003).all(1)&(head_weight>=.9999).all(1)
+        missing_ids=np.flatnonzero(unmatched);joints[missing_ids[rigid]]=head;weights[missing_ids[rigid]]=[1,0,0,0]
+        if not rigid.all():
+            selected=missing_ids[~rigid]
+            faces=np.concatenate([accessor(rig,rig_data,p['indices']).reshape(-1,3) for p in rig['meshes'][rig['nodes'][rig_body]['mesh']]['primitives']])
+            joints[selected],weights[selected]=surface_weight_transfer(binding_expected[selected],bound_positions,faces,bound_joints,bound_weights,tolerance)
+            barycentric_count=len(selected)
+    if not np.isfinite(weights).all() or np.max(abs(weights.sum(1)-1))>1e-5:raise ValueError('Invalid transferred weights')
+    original_length=len(data);mapping={}
+    for i,n in enumerate(rig['nodes']):
+        if i!=rig_body:mapping[i]=len(doc['nodes']);doc['nodes'].append(copy.deepcopy(n))
+    for old,new in mapping.items():
+        if 'children' in doc['nodes'][new]:doc['nodes'][new]['children']=[mapping[c] for c in rig['nodes'][old]['children'] if c!=rig_body]
+    roots=rig['scenes'][rig.get('scene',0)]['nodes'];doc['scenes'][doc.get('scene',0)]['nodes'] += [mapping[i] for i in roots if i!=rig_body]
+    inverse_bind=accessor(rig,rig_data,source_skin['inverseBindMatrices']).reshape(-1,4,4).transpose(0,2,1)
+    # Keep the rig's canonical inverse binds: Skeleton.pose() reconstructs its
+    # rest world matrices from them. Convert mesh coordinates instead of hiding
+    # a mesh-space transform inside the inverse binds.
+    coordinate_scale=np.linalg.norm(transform[:3,:3],axis=0)
+    if not np.allclose(coordinate_scale,coordinate_scale[0],rtol=1e-5):raise ValueError('Nonuniform bind-space conversion needs explicit normal handling')
+    rotation=transform[:3,:3]/coordinate_scale[0]
+    if not np.allclose(rotation.T@rotation,np.eye(3),atol=1e-5):raise ValueError('Sheared bind-space conversion is unsupported')
+    converted={}
+    def convert_attribute(index,kind,delta=False):
+        key=(index,kind,delta)
+        if key not in converted:
+            values=accessor(doc,data,index)
+            if kind=='POSITION':values=values@transform[:3,:3].T+(0 if delta else transform[:3,3])
+            elif kind=='TANGENT':values[:,:3]=values[:,:3]@rotation.T
+            else:values=values@rotation.T
+            converted[key]=append_accessor(doc,data,values.astype('<f4'),'VEC4' if kind=='TANGENT' else 'VEC3',5126)
+            if kind=='POSITION':doc['accessors'][converted[key]].update(min=values.min(0).tolist(),max=values.max(0).tolist())
+        return converted[key]
+    for p in primitives:
+        # Authoring correspondence is consumed here; it is not a renderer input.
+        p['attributes'].pop('_BIND_SOURCE_POSITION',None)
+        for kind in ['POSITION','NORMAL','TANGENT']:
+            if kind in p['attributes']:p['attributes'][kind]=convert_attribute(p['attributes'][kind],kind)
+        for target in p.get('targets',[]):
+            for kind in ['POSITION','NORMAL']:
+                if kind in target:target[kind]=convert_attribute(target[kind],kind,True)
+    adjusted=inverse_bind
+    pose_error=float(np.max(abs(np.linalg.inv(adjusted)-np.asarray([rig_world[i] for i in source_skin['joints']]))))
+    if pose_error>2e-5:raise ValueError('Inverse binds are incompatible with the engine skeleton pose reset')
+    ibm_index=append_accessor(doc,data,adjusted.transpose(0,2,1).reshape(-1,16).astype('<f4'),'MAT4',5126)
+    doc['skins']=[{'name':source_skin.get('name','SharedBodyRig'),'joints':[mapping[i] for i in source_skin['joints']],'inverseBindMatrices':ibm_index}];doc['nodes'][body_node]['skin']=0
+    ji=append_accessor(doc,data,joints.astype('<u2'),'VEC4',5123);wi=append_accessor(doc,data,weights.astype('<f4'),'VEC4',5126)
+    for p in primitives:p['attributes'].update(JOINTS_0=ji,WEIGHTS_0=wi)
+    # Optical roots and head-fixed tissue now follow the animated Head joint.
+    head_node=mapping[source_skin['joints'][head]];head_world=rig_world[source_skin['joints'][head]];rotation_changes={};attachments=list(doc['nodes'][body_node].get('children',[]))
+    for child in attachments:
+        node=doc['nodes'][child]
+        optical=node.get('extras',{}).get('characterEye') or ('mesh' in node and all(doc['materials'][p['material']].get('extras',{}).get('eyeLayer') for p in doc['meshes'][node['mesh']]['primitives']))
+        if not optical:raise ValueError('Nonocular body attachments require explicit parenting')
+        old_rotation=Rotation.from_quat(node.get('rotation',[0,0,0,1]));set_transform(node,np.linalg.inv(head_world)@normalization@worlds[child]);rotation_changes[child]=Rotation.from_quat(node['rotation'])*old_rotation.inv()
+        doc['nodes'][head_node].setdefault('children',[]).append(child)
+    doc['nodes'][body_node]['children']=[]
+    for i,node in enumerate(doc['nodes']):
+        if i!=body_node and body_node in node.get('children',[]):node['children'].remove(body_node)
+    set_transform(doc['nodes'][body_node],np.eye(4))
+    scene_nodes=doc['scenes'][doc.get('scene',0)]['nodes']
+    if body_node not in scene_nodes:scene_nodes.append(body_node)
+    for animation in doc.get('animations',[]):
+        for channel in animation['channels']:
+            target=channel['target']
+            if target.get('path')=='rotation' and target['node'] in rotation_changes:
+                sampler=animation['samplers'][channel['sampler']]
+                if sampler.get('interpolation','LINEAR')!='LINEAR':raise ValueError('Eye rotation retarget requires linear quaternion tracks')
+                q=accessor(doc,data,sampler['output']);q=(rotation_changes[target['node']]*Rotation.from_quat(q)).as_quat();sampler['output']=append_accessor(doc,data,q.astype('<f4'),'VEC4',5126)
+    copied={}
+    def copy_accessor(index):
+        if index not in copied:
+            original=rig['accessors'][index];copied[index]=append_accessor(doc,data,accessor(rig,rig_data,index),original['type'],original['componentType'])
+            for key in ['min','max','normalized']:
+                if key in original:doc['accessors'][copied[index]][key]=original[key]
+        return copied[index]
+    for animation in rig.get('animations',[]):
+        a=copy.deepcopy(animation)
+        for sampler in a['samplers']:sampler['input']=copy_accessor(sampler['input']);sampler['output']=copy_accessor(sampler['output'])
+        for channel in a['channels']:channel['target']['node']=mapping[channel['target']['node']]
+        doc.setdefault('animations',[]).append(a)
+    matrices=np.asarray([rig_world[i] for i in source_skin['joints']])@adjusted
+    maximum=0.
+    for batch in np.array_split(np.arange(len(positions)),max(1,len(positions)//100000)):
+        error=np.linalg.norm(skin_points(expected[batch],joints[batch],weights[batch],matrices)-expected[batch],axis=1);maximum=max(maximum,float(error.max()))
+    if maximum>2e-5:raise ValueError(f'Assembled bind pose does not preserve the source: {maximum}m')
+    out=base/'runtime/v1';out.mkdir(parents=True,exist_ok=True)
+    report={'id':sid,'status':'motion_review_required','viewerReady':False,'surfaceInput':relative_input,'surfaceSha256':hashlib.sha256(input_path.read_bytes()).hexdigest(),'rigSha256':rig_report['output_sha256'],'restPositionErrorM':maximum,'rigidHeadInsertedVertices':int(unmatched.sum()),'bodyBones':len(source_skin['joints']),'headAttachments':len(attachments),'clips':[a['name'] for a in doc.get('animations',[])],'sourceBufferBytesPreserved':bytes(data[:original_length])==bytes(read(input_path)[1]),'geometryChange':'Rigid uniform bind-space coordinate conversion of positions, normals and morph deltas; no surface reshaping','limitations':['Shared body rig currently has no independent finger bones','Motion and eye contact require visual acceptance']}
+    report['variant']=variant
+    report['barycentricWeightVertices']=barycentric_count
+    report['rigidHeadInsertedVertices']=int(unmatched.sum())-barycentric_count
+    report['poseResetMatrixError']=pose_error
+    report['outputSha256']=write_glb(doc,data,out/f'{variant}.glb');(out/f'{variant}-report.json').write_text(json.dumps(report,indent=2))
+    for name in ['ATTRIBUTION.txt','MakeHuman-LICENSE.md']:
+        if (input_path.parent/name).exists():shutil.copyfile(input_path.parent/name,out/name)
+    print(json.dumps(report))
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--id',required=True);p.add_argument('--input',required=True);p.add_argument('--variant',choices=['eyes','surfaces'],default='eyes');a=p.parse_args();assemble(a.id,a.input,a.variant)

package/assets/character-skin-authoring/scripts/authored_detail.py

@@ -0,0 +1,47 @@
+"""Bake agent-authored regional crease curves; never infer anatomy or landmarks."""
+import hashlib,json
+import numpy as np
+
+LABELS={'skin':1,'palm':2,'sole':3,'dorsal_hand':9}
+
+def curve_distance(points,curve):
+    distance=np.full(len(points),np.inf)
+    for a,b in zip(curve[:-1],curve[1:]):
+        edge=b-a;length=np.dot(edge,edge)
+        if length<=0:raise ValueError('Crease curve has a repeated point')
+        t=np.clip((points-a)@edge/length,0,1)
+        distance=np.minimum(distance,np.linalg.norm(points-a-t[:,None]*edge,axis=1))
+    return distance
+
+class AuthoredDetail:
+    def __init__(self,path,manifest,physical_height):
+        self.curves=[];self.report=None
+        if not path.exists():return
+        raw=path.read_bytes();profile=json.loads(raw)
+        if profile['sourceSha256']!=manifest['sourceSha256']:raise ValueError('Body detail profile belongs to another source')
+        for record in profile['curves']:
+            index=next(i for i,v in enumerate(manifest['views']) if v['name']==record['view'])
+            image=record['view']+'.png'
+            if profile['evidenceHashes'].get(image)!=manifest['evidenceHashes'].get(image):raise ValueError('Body detail coordinates belong to different view evidence')
+            view=manifest['views'][index];direction=np.asarray(view['direction'],float);direction/=np.linalg.norm(direction)
+            right=np.cross(direction,view.get('up',[0,0,1]));right/=np.linalg.norm(right);up=np.cross(right,direction)
+            curve=np.asarray(record['pointsPx'],float)
+            if curve.ndim!=2 or curve.shape[1]!=2 or len(curve)<2 or not np.isfinite(curve).all():raise ValueError('Invalid authored crease polyline')
+            width=record['widthM'];depth=record['depthM']
+            if not 0<width<=.003 or not 0<depth<=.00025:raise ValueError('Crease dimensions exceed the supported skin-detail range')
+            self.curves.append((index,np.asarray(view.get('targetOffset',[0,0,0]))*physical_height,right,up,direction,view['span']*physical_height,manifest['size'],curve,width,depth,LABELS[record['region']]))
+        self.report={'profileSha256':hashlib.sha256(raw).hexdigest(),'curves':len(self.curves),'provenance':profile['provenance'],'method':'agent-authored regional curves projected only onto visible independently labelled skin; physical width/depth'}
+
+    def evaluate(self,points,normals,labels,visibility):
+        result=np.zeros(len(points),np.float32)
+        for index,target,right,up,direction,span,size,curve,width,depth,region in self.curves:
+            selected=(labels==region)&((visibility&(1<<index))!=0)
+            if not selected.any():continue
+            local=points[selected]-target
+            xy=np.stack([(local@right/span+.5)*size,(.5-local@up/span)*size],1)
+            distance=curve_distance(xy,curve)*span/size
+            facing=np.clip((abs(normals[selected]@direction)-.2)/.3,0,1)
+            # A compact smooth groove avoids hard tube ends and adds no pigment.
+            relief=-depth*np.exp(-.5*(distance/width)**2)*facing*facing*(3-2*facing)
+            result[selected]=np.minimum(result[selected],relief)
+        return result

package/assets/character-skin-authoring/scripts/authored_surface_patch.py

@@ -0,0 +1,83 @@
+"""Vision-registered roughness/height exemplars, limited by labels and visibility.
+
+No inferred anatomy and no conversion of normal RGB into displacement.
+"""
+import hashlib,json
+from pathlib import Path
+import numpy as np
+from PIL import Image,ImageDraw
+from scipy.interpolate import RBFInterpolator
+from scipy.ndimage import distance_transform_edt,map_coordinates,gaussian_filter
+from authored_detail import LABELS
+
+class AuthoredSurfacePatch:
+ def __init__(self,path,manifest,physical_height,root):
+  self.patches=[];self.independent=[];self.report=None;self.attributions={}
+  if not path.exists():return
+  raw=path.read_bytes();profile=json.loads(raw)
+  if profile['sourceSha256']!=manifest['sourceSha256']:raise ValueError('Surface patch belongs to another source')
+  receipts=[]
+  for record in profile['patches']:
+   index=next(i for i,v in enumerate(manifest['views'])if v['name']==record['view']);view=manifest['views'][index];image=record['view']+'.png'
+   image_path=Path(manifest['output'])/image
+   if profile['evidenceHashes'].get(image)!=manifest['evidenceHashes'].get(image) or hashlib.sha256(image_path.read_bytes()).hexdigest()!=profile['evidenceHashes'][image]:raise ValueError('Surface patch evidence changed')
+   texture_path=root/record['roughnessTexture'];data=texture_path.read_bytes()
+   if hashlib.sha256(data).hexdigest()!=record['textureSha256']:raise ValueError('Surface patch exemplar changed')
+   provenance=record['provenance'];license_bytes=(root/provenance['licenseFile']).read_bytes()
+   if hashlib.sha256(license_bytes).hexdigest()!=provenance['licenseSha256']:raise ValueError('Surface patch license receipt changed')
+   self.attributions[provenance['licenseSha256']]=provenance['title']+'\n'+provenance['url']+'\nAdapted by vision registration and roughness remapping.\n'+license_bytes.decode()
+   donor=np.asarray(Image.open(texture_path).convert('L'),float)/255
+   source=np.asarray(record['sourcePixels'],float);target=np.asarray(record['targetPixels'],float)
+   if source.shape!=target.shape or source.ndim!=2 or source.shape[1]!=2 or len(source)<3 or not np.isfinite(source).all() or not np.isfinite(target).all():raise ValueError('Invalid surface patch correspondences')
+   size=manifest['size'];donor_size=record['sourceAnnotationImageSize'];resolution=record.get('sampleResolution',size)
+   if not isinstance(resolution,int) or not 16<=resolution<=4096:raise ValueError('Invalid patch sampling resolution')
+   if (target<0).any() or (target>=size).any() or (source<0).any() or (source>=donor_size).any():raise ValueError('Surface patch pixel outside evidence')
+   if not 0<record['featherM']<=.02:raise ValueError('Invalid surface patch feather')
+   low,high=record['roughnessRange']
+   if not 0<=low<high<=1:raise ValueError('Invalid surface patch roughness range')
+   target_mask=Image.new('L',(resolution,resolution));ImageDraw.Draw(target_mask).polygon([tuple(p*resolution/size)for p in target],fill=255);inside=np.asarray(target_mask)>0
+   yy,xx=np.nonzero(inside);mapped=RBFInterpolator(target/size,source/donor_size,kernel='thin_plate_spline',smoothing=0)(np.column_stack([xx,yy])/resolution)
+   sampled=map_coordinates(gaussian_filter(donor,1),[mapped[:,1]*(donor.shape[0]-1),mapped[:,0]*(donor.shape[1]-1)],order=1,mode='nearest')
+   # Preserve exemplar variation inside a declared art-directed physical response range.
+   rough=np.full((resolution,resolution),.5*(low+high));rough[yy,xx]=low+(high-low)*sampled
+   height=None
+   if record.get('height'):
+    h=record['height'];height_path=root/h['path']
+    if hashlib.sha256(height_path.read_bytes()).hexdigest()!=h['sha256']:raise ValueError('Surface height exemplar changed')
+    field=np.load(height_path,allow_pickle=False);bounds=np.asarray(h['boundsPx'],float)
+    if field.ndim!=2 or not np.isfinite(field).all() or np.max(abs(field))>.001 or bounds.shape!=(4,) or not np.isfinite(bounds).all() or np.any(bounds[2:]<=bounds[:2]) or not 0<h['scale']<=4 or not h.get('provenance'):
+     raise ValueError('Invalid physical surface height field or provenance')
+    coordinates=(mapped*donor_size-bounds[:2])/(bounds[2:]-bounds[:2])
+    height=np.zeros((resolution,resolution));height[yy,xx]=map_coordinates(field,[coordinates[:,1]*(field.shape[0]-1),coordinates[:,0]*(field.shape[1]-1)],order=1,mode='nearest')*h['scale']
+    self.attributions[provenance['licenseSha256']]+='\nHeight adaptation: '+json.dumps(h['provenance'])+'\n'
+   feather=np.clip(distance_transform_edt(inside)*view['span']*physical_height/resolution/record['featherM'],0,1);feather=feather*feather*(3-2*feather)
+   direction=np.asarray(view['direction'],float);direction/=np.linalg.norm(direction);right=np.cross(direction,view.get('up',[0,0,1]));right/=np.linalg.norm(right);up=np.cross(right,direction)
+   self.patches.append((index,np.asarray(view.get('targetOffset',[0,0,0]))*physical_height,right,up,direction,view['span']*physical_height,resolution,LABELS[record['region']],rough,feather,height))
+   self.independent.append(record.get('independentDetail',False))
+   receipts.append({'view':record['view'],'region':record['region'],'roughnessTexture':record['roughnessTexture'],'textureSha256':record['textureSha256'],'roughnessRange':record['roughnessRange'],'height':record.get('height'),'provenance':record['provenance'],'independentDetail':self.independent[-1],'sampleResolution':resolution})
+  self.report={'profileSha256':hashlib.sha256(raw).hexdigest(),'patches':receipts,'method':'independent vision correspondences; optional physical height; semantic labels and geometric visibility constrain application'}
+
+ def evaluate(self,points,normals,labels,visibility,base,include_independent=True):
+  return self._evaluate(points,normals,labels,visibility,base,False,include_independent)
+
+ def relief(self,points,normals,labels,visibility,include_independent=True):
+  return self._evaluate(points,normals,labels,visibility,np.zeros(len(points)),True,include_independent)
+
+ def _evaluate(self,points,normals,labels,visibility,base,use_height,include_independent):
+  total=np.zeros(len(points));value=np.zeros(len(points))
+  for independent,patch in zip(self.independent,self.patches):
+   if independent and not include_independent:continue
+   index,target,right,up,direction,span,size,region,rough,feather,height=patch
+   field=height if use_height else rough
+   if field is None:continue
+   selected=(labels==region)&((visibility&(1<<index))!=0)
+   if not selected.any():continue
+   local=points[selected]-target;xy=np.stack([(local@right/span+.5)*size,(.5-local@up/span)*size],1)
+   weight=map_coordinates(feather,[xy[:,1],xy[:,0]],order=1,mode='constant',cval=0)
+   facing=np.clip((abs(normals[selected]@direction)-.2)/.3,0,1);weight*=facing*facing*(3-2*facing)
+   value[selected]+=map_coordinates(field,[xy[:,1],xy[:,0]],order=1,mode='nearest')*weight;total[selected]+=weight
+  return base*(1-np.minimum(total,1))+value/np.maximum(total,1e-12)*np.minimum(total,1)
+
+ def independent_planes(self):
+  names=['index','target','right','up','direction','span','size','region','roughness','feather','height']
+  return [dict(zip(names,patch)) for independent,patch in zip(self.independent,self.patches) if independent]

package/assets/character-skin-authoring/scripts/brow_groom.py

@@ -0,0 +1,62 @@
+"""Short strand groom from explicit image-space brow polygons and comb guides.
+
+Sampling places designed fibers inside authored regions; it does not recognize hair.
+"""
+import numpy as np
+
+
+def inside_polygon(points, polygon):
+    polygon=np.asarray(polygon,float);inside=np.zeros(len(points),bool)
+    for a,b in zip(polygon,np.roll(polygon,-1,axis=0)):
+        if abs(b[1]-a[1])<1e-12:continue
+        inside^=((a[1]>points[:,1])!=(b[1]>points[:,1]))&(points[:,0]<(b[0]-a[0])*(points[:,1]-a[1])/(b[1]-a[1])+a[0])
+    return inside
+
+
+def build_brow(profile,points,triangles,normals,target,right,up,direction,span,size,unit,inverse,origin):
+    polygon=np.asarray(profile['polygonPx'],float);guides=np.asarray(profile['combGuidesPx'],float)
+    if polygon.ndim!=2 or polygon.shape[1]!=2 or len(polygon)<3 or not np.isfinite(polygon).all():raise ValueError('Brow needs an explicit finite polygon')
+    if guides.ndim!=3 or guides.shape[1:]!=(2,2) or len(guides)<2 or not np.isfinite(guides).all():raise ValueError('Brow needs at least two explicit comb guides')
+    vectors=guides[:,1]-guides[:,0];lengths=np.linalg.norm(vectors,axis=1)
+    if np.any(lengths<1e-6):raise ValueError('Brow comb guides must have a direction')
+    vectors/=lengths[:,None]
+    pigment=np.asarray(profile['colorLinear'],float)
+    if pigment.shape!=(3,) or not np.isfinite(pigment).all() or np.any(pigment<0) or np.any(pigment>1):raise ValueError('Brow pigment must be finite linear RGB')
+    count=int(profile['strandCount']);radii=float(profile['radiusM'])*unit
+    low,high=np.asarray(profile['lengthRangeM'],float)*unit
+    if not 1<=count<=1000 or not 0<radii<.0001*unit or not 0<low<=high<.015*unit:raise ValueError('Invalid authored brow fiber dimensions')
+    rng=np.random.default_rng(profile['seed']);roots=[]
+    for batch in range(100):
+        candidates=rng.uniform(polygon.min(0),polygon.max(0),size=(count*4,2))
+        roots.extend(candidates[inside_polygon(candidates,polygon)])
+        if len(roots)>=count:break
+    if len(roots)<count:raise ValueError('Brow polygon has insufficient area')
+    roots=np.asarray(roots[:count])
+    projected=np.stack([((points-target)@right/span+.5)*size,(.5-(points-target)@up/span)*size],1)
+    bounds=projected[triangles];selected=np.all(bounds.max(1)>=polygon.min(0)-1,axis=1)&np.all(bounds.min(1)<=polygon.max(0)+1,axis=1)
+    triangles=triangles[selected];a=points[triangles[:,0]];e1=points[triangles[:,1]]-a;e2=points[triangles[:,2]]-a
+    h=np.cross(direction,e2);det=(e1*h).sum(1);safe=np.where(abs(det)>1e-12,det,1)
+    vertices=[];vertex_normals=[];faces=[];color=[]
+    for pixel in roots:
+        ray=target+right*((pixel[0]+.5)/size-.5)*span+up*(.5-(pixel[1]+.5)/size)*span-direction*span*4
+        s=ray-a;u=(s*h).sum(1)/safe;q=np.cross(s,e1);v=(q*direction).sum(1)/safe;t=(e2*q).sum(1)/safe
+        valid=(abs(det)>1e-12)&(u>=0)&(v>=0)&(u+v<=1)&(t>0)
+        if not valid.any():raise ValueError('Authored brow root misses visible source geometry')
+        face=int(np.argmin(np.where(valid,t,np.inf)));root=ray+direction*t[face]
+        normal=normals[triangles[face]].T@np.array([1-u[face]-v[face],u[face],v[face]]);normal/=np.linalg.norm(normal)
+        weights=1/np.maximum(np.sum((guides[:,0]-pixel)**2,axis=1),9);comb=weights@vectors/weights.sum()
+        tangent=right*comb[0]-up*comb[1];tangent-=normal*np.dot(normal,tangent);tangent/=np.linalg.norm(tangent)
+        length=rng.uniform(low,high);curve=[]
+        for fraction in np.linspace(0,1,8):
+            curve.append(root+tangent*length*fraction+normal*unit*(.00004+.00018*np.sin(np.pi*fraction)+.00008*fraction))
+        curve=np.asarray(curve);along=np.gradient(curve,axis=0);along/=np.linalg.norm(along,axis=1,keepdims=True)
+        side=np.cross(along,normal);side/=np.linalg.norm(side,axis=1,keepdims=True);other=np.cross(along,side)
+        angle=np.arange(5)*2*np.pi/5;tube_normals=side[:,None,:]*np.cos(angle)[None,:,None]+other[:,None,:]*np.sin(angle)[None,:,None]
+        tube=curve[:,None,:]+tube_normals*radii*np.linspace(1,.05,8)[:,None,None];start=len(vertices)
+        vertices.extend((tube.reshape(-1,3)-origin)@inverse.T)
+        transformed=tube_normals.reshape(-1,3)@np.linalg.inv(inverse);transformed/=np.linalg.norm(transformed,axis=1,keepdims=True);vertex_normals.extend(transformed)
+        shade=np.clip(pigment*rng.uniform(.8,1.2),0,1);color.extend(np.broadcast_to(shade,(40,3)))
+        for row in range(7):
+            for k in range(5):
+                i=start+row*5+k;j=start+row*5+(k+1)%5;faces.extend([[i,j,i+5],[j,j+5,i+5]])
+    return np.asarray(vertices),np.asarray(vertex_normals),np.asarray(color),np.asarray(faces)

package/assets/character-skin-authoring/scripts/build_face_detail.py

@@ -0,0 +1,107 @@
+"""Register an attributed scan detail atlas to a generated face, preserving identity.
+
+This transfers band-limited displacement, not the scan's face shape. Height scale
+is an authoring calibration (not recovered physical capture metadata). No MERL or
+MetaHuman textures are used. All derivatives carry source/license/hash provenance.
+"""
+from pathlib import Path
+import hashlib,json
+import numpy as np
+from PIL import Image,ImageDraw
+from scipy.ndimage import gaussian_filter, distance_transform_edt
+from face_atlas import rasterize,sample,register
+from glb_arrays import read,accessor
+from workspace_paths import workspace_root
+ROOT=workspace_root(__file__)
+REFERENCE=ROOT/'highquality/references/lee-perry-smith'
+
+def pixels_to_coords(points,bounds,n=900):
+    p=np.asarray(points,dtype=float)/n;p[:,1]=1-p[:,1]
+    return np.asarray(bounds[:2])+p*(np.asarray(bounds[2:])-bounds[:2])
+
+def region_image(profile,size=2048):
+    im=Image.new('L',(size,size),0);draw=ImageDraw.Draw(im)
+    for value,kind in enumerate(['eyes','brows','lips'],1):
+        for polygon in profile['regions'][kind]:
+            draw.polygon([(x/profile['annotationImageSize']*(size-1),(1-y/profile['annotationImageSize'])*(size-1)) for x,y in polygon],fill=value)
+    return np.array(im)
+
+def verify_landmark_evidence(profile,root,source):
+    if profile.get('version',1)<2:return 'legacy_unbound_landmarks'
+    if hashlib.sha256(source.read_bytes()).hexdigest()!=profile['sourceSha256']:
+        raise ValueError('Face landmarks belong to a different source mesh')
+    image=root/profile['evidenceImage']
+    if hashlib.sha256(image.read_bytes()).hexdigest()!=profile['evidenceImageSha256']:
+        raise ValueError('Face landmark evidence image changed')
+    with Image.open(image) as pixels:
+        if pixels.size!=(profile['annotationImageSize'],profile['annotationImageSize']):
+            raise ValueError('Face landmark evidence dimensions differ')
+    return 'source_and_image_hash_verified'
+
+def build(sid='b3662'):
+    profile_path=ROOT/'highquality/materials/faces'/f'{sid}.json';profile=json.loads(profile_path.read_text())
+    evidence_status=verify_landmark_evidence(profile,ROOT,ROOT/'characters'/sid/'high/v1/source/hy31pro.glb')
+    folder=ROOT/'characters'/sid/'high/v1/materials/v2';folder.mkdir(parents=True,exist_ok=True)
+    source=REFERENCE/'LeePerrySmith.glb';j,b=read(source);pr=j['meshes'][0]['primitives'][0]
+    p=accessor(j,b,pr['attributes']['POSITION']);uv=accessor(j,b,pr['attributes']['TEXCOORD_0']);uv[:,1]=1-uv[:,1]
+    ids=accessor(j,b,pr['indices']).reshape(-1,3)
+    size=profile.get('atlasSize',2048)
+    if size not in (2048,4096):raise ValueError('Facial atlasSize must be 2048 or 4096')
+    pixel_scale=size/2048
+    scan_uv,scan_valid=rasterize(p,ids,uv,profile['sourceBounds'],size)
+    displacement=np.asarray(Image.open(REFERENCE/'Infinite-Level_02_Disp_NoSmoothUV-4096.jpg').convert('L'),dtype=float)/255
+    scan_height=sample(displacement,scan_uv)
+    # Inpaint uncovered pixels before filtering to avoid silhouette impulses.
+    nearest=distance_transform_edt(~scan_valid,return_distances=False,return_indices=True)
+    scan_height=scan_height[tuple(nearest)]
+    # Remove identity-scale form; retain scan-correlated intermediate and fine detail.
+    band=gaussian_filter(scan_height,.65*pixel_scale)-gaussian_filter(scan_height,24*pixel_scale)
+    central=band[size//3:3*size//4,size//3:2*size//3]
+    amplitude=np.percentile(np.abs(central),95)
+    band*=profile['detailAmplitudeM']/max(amplitude,1.e-6)
+    np.save(folder/'scan-band-height-m.npy',band.astype('float32'))
+    yy,xx=np.mgrid[0:size,0:size];coords=np.stack([xx,yy],-1)/(size-1)
+    bounds=np.array(profile['bounds']);target=coords*(bounds[2:]-bounds[:2])+bounds[:2]
+    mapped,valid=register(target.reshape(-1,2),pixels_to_coords(profile['targetPixels'],profile['bounds'],profile['annotationImageSize']),pixels_to_coords(profile['sourcePixels'],profile['sourceBounds'],profile.get('sourceAnnotationImageSize',900)))
+    sb=np.array(profile['sourceBounds']);lookup=((mapped-sb[:2])/(sb[2:]-sb[:2])).reshape(size,size,2)
+    height=sample(band,lookup)
+    regions=region_image(profile,size)
+    coverage=valid.reshape(size,size)&(regions==0)
+    if not coverage.any():raise ValueError('Registration has no uncovered skin; review landmark hull and exclusion polygons')
+    feather=np.clip(distance_transform_edt(coverage)/(48*pixel_scale),0,1)
+    # Roughness follows the transferred relief's local variation, with coarse oil regions.
+    dy,dx=np.gradient(height);variance=gaussian_filter(dx*dx+dy*dy,3*pixel_scale)
+    relief=np.clip(np.sqrt(variance)/max(np.percentile(np.sqrt(variance[coverage]),95),1e-9),0,1)
+    # Transfer only gentle chromatic variation from clean upper-face skin;
+    # reject beard/jaw pigment so the donor's stubble does not enter the queen.
+    scan_color=sample(np.asarray(Image.open(REFERENCE/'Map-COL.jpg'),dtype=float)/255,scan_uv)
+    chroma=np.log(np.maximum(scan_color[:,:,0],.02)/np.maximum(scan_color[:,:,1],.02))
+    chroma=gaussian_filter(chroma,4*pixel_scale)-gaussian_filter(chroma,50*pixel_scale)
+    pigment=sample(chroma,lookup)*np.clip((lookup[:,:,1]-.53)/.09,0,1)
+    pigment=np.clip(pigment*4,-.3,.3)
+    packed=np.stack([np.clip(.5+height/profile['detailHeightRangeM'],0,1),.45+.20*relief,.5+pigment,feather],axis=-1)
+    Image.fromarray(np.round(packed*255).astype('uint8'),'RGBA').save(folder/'face-detail.png')
+    # Authored appearance deltas, NOT captured expression scans. Modulate the
+    # registered relief within facial regions; the source HY geometry stays intact.
+    x=coords[:,:,0];z=coords[:,:,1]
+    forehead=np.exp(-((x-.5)/.22)**2-((z-.69)/.11)**2)
+    smile=np.exp(-((abs(x-.5)-.15)/.10)**2-((z-.23)/.13)**2)
+    squint=np.exp(-((abs(x-.5)-.19)/.10)**2-((z-.46)/.09)**2)
+    delta=np.stack([height*forehead*.8,height*smile*.6,height*squint*.7],-1)
+    dynamic=np.concatenate([np.clip(.5+delta/profile['detailHeightRangeM'],0,1),np.clip((smile+forehead+squint)*feather,0,1)[...,None]],axis=-1)
+    Image.fromarray(np.round(dynamic*255).astype('uint8'),'RGBA').save(folder/'face-expression.png')
+    np.save(folder/'face-height-m.npy' ,height.astype('float32'))
+    Image.fromarray(regions.astype('uint8')).save(folder/'face-regions.png')
+    # Useful independent normal preview in the registered face plane.
+    physical_height=json.loads((ROOT/'characters'/sid/'high/v1/output/viewer-profile.json').read_text())['height']
+    spacing=(bounds[2:]-bounds[:2])*physical_height/(size-1)
+    dy,dx=np.gradient(height,spacing[1],spacing[0]);n=np.stack([-dx,-dy,np.ones_like(height)],-1);n/=np.linalg.norm(n,axis=-1,keepdims=True)
+    Image.fromarray(np.round((n*.5+.5)*255).astype('uint8')).save(folder/'face-normal-preview.png')
+    report={'id':sid,'landmarkEvidence':evidence_status,'method':'landmark-registered, band-limited scan displacement','author':'Lee Perry-Smith / Infinite Realities','license':'CC BY 3.0','licenseUrl':'https://creativecommons.org/licenses/by/3.0/','sourceUrl':'https://github.com/mrdoob/three.js/tree/r186/examples/models/gltf/LeePerrySmith','changes':'Projected into a facial atlas, band-pass filtered, amplitude calibrated, landmark-warped and masked. Only upper-face chromatic residual is transferred; beard pigment and face shape are not copied.','expressionMaps':'Authored modulation of scan relief; not captured expressions or a biological color model','scale':'Authoring estimate, not measured displacement units','heightRangeM':profile['detailHeightRangeM'],'profile_sha256':hashlib.sha256(profile_path.read_bytes()).hexdigest(),'inputs':{f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in REFERENCE.iterdir() if f.is_file()},'source_sha256':hashlib.sha256((ROOT/'characters'/sid/'high/v1/source/hy31pro.glb').read_bytes()).hexdigest()}
+    report['atlasSize']=size;report['texelSpacingM']=spacing.tolist();report['filterScaleRelativeTo2048']=pixel_scale
+    (folder/'face-detail-provenance.json').write_text(json.dumps(report,indent=2)+'\n')
+    (folder/'ATTRIBUTION.txt').write_text('Facial detail adapted from Infinite, 3D Head Scan by Lee Perry-Smith / Infinite Realities.\nCC BY 3.0: https://creativecommons.org/licenses/by/3.0/\nSource: three.js r186 examples/models/gltf/LeePerrySmith.\nModified by landmark registration, filtering, masking and amplitude calibration.\n')
+    print(json.dumps({'id':sid,'atlasSize':size,'heightP95Mm':float(np.percentile(abs(height[coverage]),95)*1000)}))
+if __name__=='__main__':
+    import argparse
+    parser=argparse.ArgumentParser();parser.add_argument('--id',default='b3662');build(parser.parse_args().id)

package/assets/character-skin-authoring/scripts/build_surface_candidate.py

@@ -0,0 +1,28 @@
+"""Build reviewed evidence into a separate surface/eye/runtime candidate, fail-fast.
+
+Authoring and visual acceptance remain agent tasks. This command never selects anatomy,
+promotes viewer readiness, modifies the original model, or runs paid generation.
+"""
+import argparse,json,subprocess,sys
+from pathlib import Path
+
+from workspace_paths import workspace_root
+ROOT=workspace_root(__file__)
+
+def build(character,evidence,masks,eyes=None,assemble=False):
+    base=ROOT/'characters'/character/'high/v1'
+    for file in [evidence/'manifest.json',masks/'report.json',masks/'material-0-surface.npz',base/'materials/v2/face-detail.png',base/'materials/v2/face-expression.png',base/'materials/v2/scan-band-height-m.npy']:
+        if not file.is_file():raise ValueError(f'Missing authored input: {file}')
+    if eyes and json.loads(eyes.read_text())['id']!=character:raise ValueError('Eye profile character mismatch')
+    def run(script,*args):
+        subprocess.run([sys.executable,str(Path(__file__).resolve().parent/script),*map(str,args)],cwd=ROOT,check=True)
+    run('vision_materials.py','--id',character,'--evidence',evidence,'--masks',masks)
+    run('vision_blend_materials.py','--id',character,'--all-surfaces')
+    if eyes:run('eye_assets.py','--profile',eyes)
+    if assemble:
+        run('assemble_character.py','--id',character,'--input','materials/v4/character.glb','--variant','surfaces')
+        if eyes:run('assemble_character.py','--id',character,'--input','eyes/v1/character.glb','--variant','eyes')
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--id',required=True);p.add_argument('--evidence',required=True,type=Path);p.add_argument('--masks',required=True,type=Path);p.add_argument('--eyes-profile',type=Path);p.add_argument('--assemble',action='store_true');a=p.parse_args()
+    build(a.id,a.evidence.resolve(),a.masks.resolve(),a.eyes_profile.resolve() if a.eyes_profile else None,a.assemble)

package/assets/character-skin-authoring/scripts/canthus_wall.py

@@ -0,0 +1,57 @@
+"""Designed lining between an explicitly authored canthus and the globe."""
+import numpy as np
+from eyelid_morph import conform_open_lid,surface_normals,surface_normal_groups
+from eyelid_patch import lid_contact_depth,corner_contact_depth
+
+def lining_depth_at_radius(radial,corner_radial,source_depth,radius,iris,unit,reconstructed=True):
+    """Depth on the authored corner lining, for tissue supported by that lining."""
+    swept=iris*np.cos(.35)+np.sqrt(radius*radius-iris*iris)*np.sin(.35)
+    inner=max(radius*.88,swept+.00035*unit)
+    if inner>=radius or not inner<=radial<=corner_radial or corner_radial<=inner:
+        raise ValueError('Authored corner tissue lies outside its lining support')
+    globe=np.sqrt(max(0,radius*radius-corner_radial*corner_radial))
+    if reconstructed:boundary=float(lid_contact_depth(corner_radial,radius,globe,source_depth))+.00025*unit
+    else:boundary=max(source_depth,globe+.00025*unit) if corner_radial<radius and source_depth>0 else source_depth
+    inner_depth=np.sqrt(radius*radius-inner*inner)-.00035*unit
+    t=(radial-inner)/(corner_radial-inner)
+    return inner_depth*(1-t)+(boundary-.0003*unit)*t
+
+
+def build_canthus_wall(profile,opening,sample_surface,inverse,origin):
+    contour=np.asarray(opening['contour']);indices=profile['contourIndices']
+    if len(indices)<3:raise ValueError('A corner wall needs upper, corner and lower landmarks')
+    path=contour[indices];pixels=np.concatenate([a[None,:]*(1-np.arange(12)[:,None]/12)+b[None,:]*(np.arange(12)[:,None]/12) for a,b in zip(path[:-1],path[1:])]+[path[-1:]])
+    right=opening['right'];up=opening['up'];forward=-opening['direction'];center=opening['center'];radius=opening['radius'];unit=opening['unit']
+    plane=opening['target']+right[None,:]*((pixels[:,0]/opening['size']-.5)*opening['span'])[:,None]+up[None,:]*((.5-pixels[:,1]/opening['size'])*opening['span'])[:,None]
+    xy=np.stack([(plane-center)@right,(plane-center)@up],1);rad=np.linalg.norm(xy,axis=1)
+    swept_iris=opening['iris']*np.cos(.35)+np.sqrt(radius*radius-opening['iris']**2)*np.sin(.35)
+    inner_radius=max(radius*.88,swept_iris+.00035*unit)
+    if inner_radius>=radius:raise ValueError('Authored optical dimensions leave no lining clearance for the reviewed gaze range')
+    active=np.flatnonzero(rad>inner_radius)
+    if len(active)<3 or np.any(np.diff(active)!=1):raise ValueError('Reviewed corner must form one contiguous lining outside the globe center')
+    plane=plane[active];xy=xy[active];rad=rad[active]
+    boundary=np.asarray([sample_surface(p) for p in plane])
+    if profile.get('contactMethod') == 'reconstructed-lid-v1':
+        # Use precisely the reconstructed aperture's depth, rather than the
+        # old source eye surface, which is removed by the lid-band exporter.
+        source_depth=(boundary-center)@forward
+        globe_depth=np.sqrt(np.maximum(0,radius*radius-rad*rad))
+        depth=np.array([corner_contact_depth(r,g,s,p,opening) for r,g,s,p in zip(rad,globe_depth,source_depth,plane)])+.00025*unit
+        boundary=center+xy[:,0,None]*right+xy[:,1,None]*up+depth[:,None]*forward
+    elif profile.get('contactMethod') is not None:
+        raise ValueError('Unsupported canthus contact method')
+    boundary,_=conform_open_lid(boundary,opening)
+    inner_xy=xy*(inner_radius/rad)[:,None];inner=center+inner_xy[:,0,None]*right+inner_xy[:,1,None]*up+forward*(np.sqrt(radius*radius-inner_radius*inner_radius)-.00035*unit)
+    rows=7;vertices=[];roots=[];weights=[];faces=[];count=len(boundary)
+    for row,t in enumerate(np.linspace(0,1,rows)):
+        # The near-lid edge shares its support point with the source lid, but is
+        # slightly recessed. The far edge remains behind the globe during blink.
+        vertices.extend(inner*(1-t)+(boundary-forward*.0003*unit)*t)
+        roots.extend(boundary);weights.extend(np.full(count,t))
+        if row:
+            for j in range(count-1):
+                a=(row-1)*count+j;b=a+1;faces.extend([[a,b,a+count],[b,b+count,a+count]])
+    vertices=(np.asarray(vertices)-origin)@inverse.T;faces=np.asarray(faces)
+    normals=surface_normals(vertices,faces,surface_normal_groups(vertices))
+    colors=np.broadcast_to(profile['colorLinear'],vertices.shape).copy()
+    return (vertices,normals,colors,faces),(np.asarray(roots)-origin)@inverse.T,np.asarray(weights)