#!/usr/bin/env python3
"""Deterministic proposed Crown Key exterior geometry. No source/canon/engine acceptance.
Pure stdlib+numpy; emits editable OBJ, glTF/GLB, same-model SVG views and drawings.
"""
import argparse, base64, hashlib, html, json, math, struct
from pathlib import Path
try:
    import numpy as np
except ImportError:
    np = None  # --check deliberately works in the stdlib-only CI environment.

PALETTE={'stone':'#e6dfcf','glass':'#387b85','metal':'#656f71','wood':'#97714d','green':'#5d7951','amber':'#d9a754','white':'#f3f1e6','dark':'#293b42','water':'#71c3c7'}
FACES=((0,3,2,1),(4,5,6,7),(0,1,5,4),(1,2,6,5),(2,3,7,6),(3,0,4,7))
def dump(path,data):path.parent.mkdir(parents=True,exist_ok=True);path.write_text(json.dumps(data,indent=2)+'\n')
def sha(path):return hashlib.sha256(path.read_bytes()).hexdigest()
def rot(p,a):
    a=math.radians(a);c,s=math.cos(a),math.sin(a)
    return [p[0]*c-p[1]*s,p[0]*s+p[1]*c,p[2]]
def triangulate(vertices,face):
    """Ear clipping preserves concave polygon caps; no invalid triangle fans."""
    if len(face)==3:return [tuple(face)]
    vv=np.asarray(vertices)[list(face)];normal=np.zeros(3)
    for q,r in zip(vv,np.roll(vv,-1,axis=0)):normal+=np.cross(q,r)
    drop=int(np.argmax(np.abs(normal)));xy=np.delete(vv,drop,axis=1);area=sum(xy[i,0]*xy[(i+1)%len(xy),1]-xy[(i+1)%len(xy),0]*xy[i,1] for i in range(len(xy)))
    sign=1 if area>0 else -1;remaining=list(range(len(face)));out=[]
    def cross(a,b,c):return (b[0]-a[0])*(c[1]-a[1])-(b[1]-a[1])*(c[0]-a[0])
    while len(remaining)>3:
        found=False
        for k,i in enumerate(remaining):
            prev,nxt=remaining[k-1],remaining[(k+1)%len(remaining)];a,b,c=xy[prev],xy[i],xy[nxt]
            if sign*cross(a,b,c)<=1e-9:continue
            inside=False
            for j in remaining:
                if j in [prev,i,nxt]:continue
                q=xy[j]
                if all(sign*z>=-1e-9 for z in [cross(a,b,q),cross(b,c,q),cross(c,a,q)]):inside=True;break
            if inside:continue
            out.append((face[prev],face[i],face[nxt]));remaining.pop(k);found=True;break
        if not found:raise ValueError('Cannot triangulate polygon: self-intersection, duplicate or collinear boundary')
    out.append(tuple(face[i] for i in remaining));return out
class Model:
    def __init__(self):self.parts=[]
    def mesh(self,name,v,f,mat='stone'):
        self.parts.append({'name':name,'v':np.array(v,dtype=float),'f':[tuple(x) for x in f],'mat':mat if mat in PALETTE else 'stone'})
    def box(self,name,center,size,mat='stone',angle=0):
        x,y,z=np.array(size)/2;v=[[a*x,b*y,c*z] for c in [-1,1] for b in [-1,1] for a in [-1,1]]
        v=np.array(v)[[0,1,3,2,4,5,7,6]]
        v=np.array([rot(p,angle) for p in v])+np.array(center)
        self.mesh(name,v,FACES,mat)
    def beam(self,name,start,end,width=.5,depth=None,mat='stone'):
        a,b=np.array(start,float),np.array(end,float);d=b-a;l=np.linalg.norm(d)
        if l<1e-6:return
        d/=l;h=np.cross(d,[0,0,1]);h=h/np.linalg.norm(h) if np.linalg.norm(h)>1e-7 else np.array([1.,0,0]);q=np.cross(d,h)
        w=width/2;t=(depth or width)/2
        v=[p+h*i*w+q*j*t for p in [a,b] for j in [-1,1] for i in [-1,1]]
        self.mesh(name,np.array(v)[[0,1,3,2,4,5,7,6]],FACES,mat)
    def cylinder(self,name,center,rx,ry,h,mat='glass',sides=32):
        v=[]
        for z in [-h/2,h/2]:
            for i in range(sides):
                a=i*2*math.pi/sides;v.append([center[0]+rx*math.cos(a),center[1]+ry*math.sin(a),center[2]+z])
        f=[tuple(reversed(range(sides))),tuple(range(sides,sides*2))]+[(i,(i+1)%sides,(i+1)%sides+sides,i+sides) for i in range(sides)]
        self.mesh(name,v,f,mat)
    def arc(self,name,rx,ry,inner,start,end,z,h,mat='stone',segments=36):
        for i in range(segments):
            aa=[math.radians(start+(end-start)*k/segments) for k in [i,i+1]]
            poly=[[r*rx*math.cos(a),r*ry*math.sin(a),zz] for zz in [z,z+h] for r,a in [(inner,aa[0]),(1,aa[0]),(1,aa[1]),(inner,aa[1])]]
            self.mesh(f'{name}_{i:02}',poly,FACES,mat)
    def primitive(self,c):
        k=c.get('kind','box');n=c.get('name',f'component_{len(self.parts)}');mat=c.get('material','stone');loc=c.get('location',c.get('center',[0,0,0]));size=c.get('size',[1,1,1])
        if k=='box':self.box(n,loc,size,mat,c.get('rotation_z_deg',0))
        elif k=='beam':self.beam(n,c['start'],c['end'],c.get('width_m',.5),c.get('depth_m'),mat)
        elif k=='cylinder':self.cylinder(n,loc,size[0],size[1],size[2],mat,c.get('sides',24))
        elif k=='mesh':self.mesh(n,c['vertices'],c['faces'],mat)
        elif k=='extrusion':
            poly=c['polygon'];count=len(poly);v=[[x,y,z] for z in [c['z_min'],c['z_max']] for x,y in poly]
            f=[tuple(reversed(range(count))),tuple(range(count,count*2))]+[(i,(i+1)%count,(i+1)%count+count,i+count) for i in range(count)]
            self.mesh(n,v,f,mat)
        else:raise ValueError(f'Unknown primitive {k}')
    def bounds(self):
        v=np.concatenate([p['v'] for p in self.parts]);return v.min(axis=0),v.max(axis=0)

def build(a):
    m=Model();w,d,h=[float(a[k]) for k in ['width_m','depth_m','height_m']];n=int(a.get('floors',max(1,round(h/3.8))));fam=a['family'];fh=h/n
    if 'components' in a:
        for c in a['components']:m.primitive(c)
    elif fam=='twist':
        rx,ry=w/2,d/2
        for i in range(n):
            m.cylinder(f'L{i:02}_floor',[0,0,i*fh+.18],rx,ry,.36,'stone')
            m.cylinder(f'L{i:02}_glazing',[0,0,(i+.5)*fh],rx*.982,ry*.982,fh-.36,'glass')
        count=int(a.get('helix_count',3));turn=float(a.get('twist_deg',140));rw=float(a.get('ribbon_width_m',2.8));steps=max(48,n*3)
        for band in range(count):
            for i in range(steps):
                z1=h*i/steps;z2=h*(i+1)/steps;ang1=band*360/count+turn*i/steps;ang2=band*360/count+turn*(i+1)/steps
                p1=[rx*1.035*math.cos(math.radians(ang1)),ry*1.035*math.sin(math.radians(ang1)),z1]
                p2=[rx*1.035*math.cos(math.radians(ang2)),ry*1.035*math.sin(math.radians(ang2)),z2]
                m.beam(f'helix_{band}_{i:03}',p1,p2,rw,.42,'white')
        m.cylinder('roof_drum',[0,0,h+.3],rx,ry,.6,'stone')
    elif fam in ['box','tapered','frame','terraced','split']:
        for i in range(n):
            t=i/max(1,n-1);scale=1-(1-float(a.get('taper_top',.72)))*t if fam in ['tapered','frame'] else 1
            if a.get('upper_setback') and i>=a['upper_setback']['start_floor']:scale*=a['upper_setback']['scale']
            step=min(w*.34,float(a.get('terrace_step_m',1.5))*i) if fam=='terraced' else 0
            ww=w*scale-step;dd=d*scale-step
            if fam=='split':
                gap=float(a.get('split_gap_m',w*.18));bw=(ww-gap)/2
                for side in [-1,1]:
                    cx=side*(gap+bw)/2;m.box(f'L{i:02}_blade{side}_slab',[cx,0,i*fh+.15],[bw,dd,.3],'stone');m.box(f'L{i:02}_blade{side}_glazing',[cx,0,(i+.5)*fh],[bw-.4,dd-.4,fh-.3],'glass')
            else:
                m.box(f'L{i:02}_slab',[0,0,i*fh+.16],[ww,dd,.32],'stone');m.box(f'L{i:02}_glazing',[0,0,(i+.5)*fh],[ww-.5,dd-.5,fh-.32],'glass')
                for x in np.linspace(-ww/2+.8,ww/2-.8,max(3,int(ww/5))):m.box(f'L{i:02}_mullion_{x:.2f}',[x,-dd/2+.17,(i+.5)*fh],[.12,.18,fh-.3],'metal')
                if fam=='terraced':
                    m.box(f'L{i:02}_front_planter',[0,-dd/2-.25,i*fh+.65],[ww,.5,.75],'green')
        if fam=='frame':
            v=a.get('frame_variant','tall');tip=h+(a.get('crown_height_m',h*.12) if v=='tall' else h*.035 if v=='mid' else 0)
            for side in [-1,1]:
                y=side*(d/2+.6);m.beam(f'exoframe_A_left_{side}',[-w*.49,y,0],[w*.15,y,tip],max(.9,w*.035),mat='white');m.beam(f'exoframe_A_right_{side}',[w*.49,y,0],[w*.15,y,tip],max(.9,w*.035),mat='white');m.beam(f'exoframe_cross_{side}',[-w*.36,y,h*.27],[w*.4,y,h*.72],max(.6,w*.025),mat='white')
        if fam=='split':
            level=int(a.get('bridge_level',n//2));m.box('garden_bridge_deck',[0,0,level*fh],[w*.75,d*.3,.55],'stone');m.box('garden_bridge_glazing',[0,0,level*fh+2],[w*.75,d*.3,3.2],'glass');m.box('bridge_roof_garden',[0,0,level*fh+3.75],[w*.76,d*.32,.6],'green')
        if fam!='split':
            roof=w*(float(a.get('taper_top',.72)) if fam in ['tapered','frame'] else 1)- (min(w*.34,float(a.get('terrace_step_m',1.5))*(n-1)) if fam=='terraced' else 0)
            m.box('roof',[0,0,h],[roof,d*.85,.4],'stone')
    elif fam=='crescent':
        span=float(a.get('arc_degrees',210));inner=float(a.get('inner_radius_ratio',.58));start=90-span/2;end=90+span/2
        for i in range(n):
            m.arc(f'L{i:02}_balcony',w/2,d/2,inner,start,end,i*fh,.36,'stone')
            m.arc(f'L{i:02}_glazing',w/2-.25,d/2-.25,min(.95,inner+.02),start,end,i*fh+.36,fh-.36,'glass')
        m.arc('roof_garden',w/2,d/2,inner,start,end,h,.5,'green');m.box('arrival_canopy',[0,-d*.14,3.8],[w*.28,d*.24,.5],'stone')
    elif fam=='arcade':
        shape=a.get('arcade_shape','straight');bays=int(a.get('bays',7));bw=w/bays;ah=float(a.get('arch_height_m',h*.65));steps=10
        for bay in range(bays):
            ang=(bay/(max(1,bays-1))-.5)*80 if shape=='curved' else 0
            x=-w/2+(bay+.5)*bw;y=(x*x/(w*1.4)) if shape=='curved' else 0
            if shape=='corner' and bay>=bays//2:x=w*.1;y=(bay-bays//2+.5)*bw;ang=90
            def at(xx,yy,zz):return np.array(rot([xx,yy,zz],ang))+[x,y,0]
            for side in [-1,1]:
                for end in [-1,1]:m.box(f'bay{bay}_pier{side}_{end}',at(end*bw/2,side*d*.34,ah*.26),[bw*.13,d*.15,ah*.52],'stone',ang)
                for j in range(steps):
                    t1=math.pi*j/steps;t2=math.pi*(j+1)/steps
                    p1=at(-math.cos(t1)*bw*.5,side*d*.34,ah*.48+math.sin(t1)*ah*.43);p2=at(-math.cos(t2)*bw*.5,side*d*.34,ah*.48+math.sin(t2)*ah*.43)
                    m.beam(f'bay{bay}_arch{side}_{j}',p1,p2,bw*.13,d*.15,'stone')
            m.box(f'bay{bay}_roof',at(0,0,h-.18),[bw*1.03,d,.36],'stone',ang)
            m.box(f'bay{bay}_upperglass',at(0,0,ah+(h-ah)*.5),[bw*.84,d*.62,max(.1,h-ah-.4)],'glass',ang)
        m.box('promenade_slab',[0,0,-.15],[w,d,.3],'stone')
    elif fam in ['pavilion','canopy']:
        # Thin four-corner saddle sheet: shape is visible from every model view.
        seg=12;v=[]
        for j in range(seg+1):
            for i in range(seg+1):
                x=(i/seg-.5)*w;y=(j/seg-.5)*d;z=h*.66+h*.32*((x/(w/2))**2-(y/(d/2))**2)
                v.append([x,y,z])
        f=[]
        hole=a.get('pavilion_shape')=='courtyard'
        for j in range(seg):
            for i in range(seg):
                if hole and (i-seg/2)**2+(j-seg/2)**2<(seg*.19)**2:continue
                k=j*(seg+1)+i;f.append((k,k+1,k+seg+2,k+seg+1))
        m.mesh('saddle_roof_candidate',v,f,'stone')
        for x in [-w*.38,w*.38]:
            for y in [-d*.32,d*.32]:m.beam(f'branch_support_{x}_{y}',[x*.65,y*.6,0],[x,y,h*.65],max(.35,w*.025),mat='stone')
        if fam=='pavilion':
            m.box('glazed_room',[0,0,h*.27],[w*.67,d*.62,h*.54],'glass')
        m.box('pavilion_base',[0,0,-.15],[w,d,.3],'stone')
    elif fam=='bridge':
        m.box('span_deck',[0,0,h*.3],[w,d,.6],'stone')
        for y in [-d*.46,d*.46]:
            m.box(f'parapet_{y}',[0,y,h*.3+.8],[w,.18,1.1],'glass')
            for x in np.linspace(-w*.45,w*.45,7):m.beam(f'arch_{x}_{y}',[x,y,h*.3],[x,y,h*.3+max(.4,h*math.sin((x/w+.5)*math.pi))],.25,mat='metal')
    elif fam=='dock':
        m.box('dock_deck',[0,0,h*.6],[w,d,.4],'wood')
        for x in np.linspace(-w*.45,w*.45,6):
            for y in [-d*.38,d*.38]:m.cylinder(f'piling_{x}_{y}',[x,y,h*.3],.25,.25,h*.6,'metal',12)
        for x in np.linspace(-w*.35,w*.35,4):m.box(f'finger_{x}',[x,-d*.8,h*.6],[w*.065,d*.8,.35],'wood')
    elif fam=='seawall':
        m.box('wall',[0,0,h*.5],[w,d,h],'stone');m.box('cap',[0,0,h],[w*1.02,d*1.15,.3],'stone')
        for x in np.linspace(-w*.45,w*.45,8):m.box(f'fender_{x}',[x,-d*.56,h*.45],[.35,.3,h*.7],'dark')
    else:raise ValueError(f'Unknown family {fam}')
    for c in a.get('extras',[]):m.primitive(c)
    if not m.parts:raise ValueError('Empty model')
    return m

def obj(m,p):
    lines=['# PROPOSED EXTERIOR CANDIDATE; metres; Z-up; front -Y','mtllib model.mtl'];offset=1
    for a in m.parts:
        lines+=['o '+a['name'],'usemtl '+a['mat']]+['v '+' '.join(f'{c:.6f}' for c in v) for v in a['v']]
        lines+=['f '+' '.join(str(i+offset) for i in tri) for f in a['f'] for tri in triangulate(a['v'],f)];offset+=len(a['v'])
    p.write_text('\n'.join(lines)+'\n')
    p.with_suffix('.mtl').write_text('\n'.join(f'newmtl {k}\nKd '+ ' '.join(f'{int(v[i:i+2],16)/255:.5f}' for i in [1,3,5])+ '\nNs 45\n' for k,v in PALETTE.items()))

def gltf(m,p):
    data=bytearray();views=[];acc=[];meshes=[];nodes=[];materials=[]
    for k,c in PALETTE.items():materials.append({'name':k,'pbrMetallicRoughness':{'baseColorFactor':[int(c[i:i+2],16)/255 for i in [1,3,5]]+[1],'metallicFactor':.45 if k=='metal' else .12,'roughnessFactor':.22 if k=='glass' else .7},'doubleSided':True})
    def add(ar,ctype,typ,target):
        while len(data)%4:data.append(0)
        off=len(data);raw=ar.tobytes();data.extend(raw);vi=len(views);views.append({'buffer':0,'byteOffset':off,'byteLength':len(raw),'target':target});ai=len(acc);spec={'bufferView':vi,'componentType':ctype,'count':len(ar),'type':typ}
        if typ=='VEC3':spec.update(min=ar.min(axis=0).tolist(),max=ar.max(axis=0).tolist())
        acc.append(spec);return ai
    for part in m.parts:
        # Right-handed glTF Y-up: Blender(x,y,z) -> (x,z,-y).
        v=part['v'][:,[0,2,1]].copy();v[:,2]*=-1;v=v.astype('<f4');tri=[]
        for f in part['f']:
            for triangle in triangulate(part['v'],f):tri.extend(triangle)
        inds=np.array(tri,dtype='<u4');pi=add(v,5126,'VEC3',34962);ii=add(inds,5125,'SCALAR',34963)
        meshes.append({'name':part['name'],'primitives':[{'attributes':{'POSITION':pi},'indices':ii,'material':list(PALETTE).index(part['mat'])}]});nodes.append({'name':part['name'],'mesh':len(meshes)-1})
    j={'asset':{'version':'2.0','generator':'Lost Souls proposed exterior batch R01'},'scene':0,'scenes':[{'nodes':list(range(len(nodes)))}],'nodes':nodes,'meshes':meshes,'materials':materials,'bufferViews':views,'accessors':acc,'buffers':[{'byteLength':len(data)}],'extras':{'status':'proposed_exterior_candidate','acceptance':{'dimensions':False,'shell':False,'engine':False},'units':'metres','front_axis':'+Z','source_up':'Z','export_up':'Y'}}
    plain=json.dumps(j,separators=(',',':')).encode();plain+=b' '*((-len(plain))%4);binary=bytes(data)+b'\0'*((-len(data))%4)
    p.with_suffix('.glb').write_bytes(struct.pack('<III',0x46546c67,2,12+8+len(plain)+8+len(binary))+struct.pack('<II',len(plain),0x4e4f534a)+plain+struct.pack('<II',len(binary),0x004e4942)+binary)
    j['buffers'][0]['uri']='data:application/octet-stream;base64,'+base64.b64encode(data).decode();p.write_text(json.dumps(j,separators=(',',':'))+'\n')

CAMERAS={'hero':{'azimuth_deg':-53,'elevation_deg':22},'rear':{'azimuth_deg':127,'elevation_deg':20},'entry':{'azimuth_deg':-90,'elevation_deg':7},'detail':{'azimuth_deg':-30,'elevation_deg':32}}
def cameras(m,a):
    lo,hi=m.bounds();size=hi-lo;middle=(lo+hi)/2;out={}
    for name,c in CAMERAS.items():
        c=dict(c);c['target_m']=middle.tolist();c['framing']='complete model'
        if name=='entry':
            c['target_m']=a.get('entry_target_m',[float(middle[0]),float(lo[1]),float(lo[2]+min(size[2]*.12,5))]);c['ortho_width_m']=float(a.get('entry_view_width_m',max(8,min(size[0]*.7,size[2]*1.5+8))));c['framing']='arrival / base facade crop; geometric opening not accepted'
        elif name=='detail':
            c['target_m']=a.get('detail_target_m',[float(middle[0]+size[0]*.16),float(lo[1]+size[1]*.16),float(lo[2]+size[2]*.74)]);c['ortho_width_m']=float(a.get('detail_view_width_m',max(6,min(size[0]*.65,size[2]*.6+5))));c['framing']='upper facade / defining structure crop'
        c.update(a.get('camera_overrides',{}).get(name,{}))
        az,el=math.radians(c['azimuth_deg']),math.radians(c['elevation_deg']);distance=float(max(size)*3)
        c['position_m']=(np.array(c['target_m'])+distance*np.array([math.cos(az)*math.cos(el),math.sin(az)*math.cos(el),math.sin(el)])).tolist();out[name]=c
    return out
def render(m,a,path,cam,mode='view'):
    az,el=math.radians(cam['azimuth_deg']),math.radians(cam['elevation_deg']);right=np.array([-math.sin(az),math.cos(az),0]);eye=np.array([math.cos(az)*math.cos(el),math.sin(az)*math.cos(el),math.sin(el)]);up=np.cross(eye,right)
    lo,hi=m.bounds();centre=np.array(cam.get('target_m',((lo+hi)/2).tolist()));points=np.concatenate([p['v'] for p in m.parts]);proj=np.stack([(points-centre)@right,(points-centre)@up],axis=1);mn=proj.min(axis=0);mx=proj.max(axis=0);scale=min(1040/max(mx[0]-mn[0],1),650/max(mx[1]-mn[1],1));polys=[]
    if 'ortho_width_m' in cam:scale=1040/cam['ortho_width_m'];mn=np.array([-cam['ortho_width_m']/2,-325/scale]);mx=-mn
    for part in m.parts:
        for f in part['f']:
            v=part['v'][list(f)];normal=np.cross(v[1]-v[0],v[2]-v[0]);ln=np.linalg.norm(normal)
            if ln<1e-9:continue
            normal/=ln
            if np.dot(normal,eye)<.0001:continue
            q=v-centre;xy=np.stack([q@right,q@up],axis=1);xy[:,0]=600+(xy[:,0]-(mn[0]+mx[0])/2)*scale;xy[:,1]=414-(xy[:,1]-(mn[1]+mx[1])/2)*scale
            color=PALETTE[part['mat']];shade=.66+.34*abs(float(np.dot(normal,np.array([-.4,-.5,.77]))));rgb=[min(255,int(int(color[i:i+2],16)*shade)) for i in [1,3,5]];fill='#' +''.join(f'{c:02x}' for c in rgb)
            polys.append((float(v.mean(axis=0)@eye),f'<polygon points="'+ ' '.join(f'{x:.2f},{y:.2f}' for x,y in xy)+f'" fill="{fill}"/>'))
    polys.sort(key=lambda x:x[0]);title=html.escape(a['name']);ident=html.escape(a['id']);dim=hi-lo
    svg=f'<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="860" viewBox="0 0 1200 860"><defs><clipPath id="viewport"><rect x="0" y="83" width="1200" height="704"/></clipPath></defs><rect width="1200" height="860" fill="#edf1ef"/><text x="36" y="38" fill="#243c42" font-family="sans-serif" font-size="25">{title}</text><text x="36" y="65" fill="#4b6266" font-family="sans-serif" font-size="15">{ident} · R01 · {html.escape(mode)} · same editable model</text><g clip-path="url(#viewport)" stroke="#34454b" stroke-width="0.35">'+''.join(p for _,p in polys)+f'</g><rect x="0" y="787" width="1200" height="73" fill="#16343c"/><text x="28" y="816" fill="#fff" font-family="sans-serif" font-size="16">PROPOSED CANDIDATE · dimensions / shell / engine acceptance pending</text><text x="28" y="842" fill="#c5dfdf" font-family="sans-serif" font-size="14">Measured model bounds {dim[0]:.2f} × {dim[1]:.2f} × {dim[2]:.2f} m · model Z-up / front −Y · no district placement</text></svg>'
    path.parent.mkdir(parents=True,exist_ok=True);path.write_text(svg)

def section(m,a,p):
    # Exact intersection of every polygon with source-model plane x=0.
    seg=[]
    for part in m.parts:
        for f in part['f']:
            vv=part['v'][list(f)];pts=[]
            for q,r in zip(vv,np.roll(vv,-1,axis=0)):
                if q[0]*r[0]<0:pts.append(q+(r-q)*(-q[0])/(r[0]-q[0]))
                elif abs(q[0])<1e-8:pts.append(q)
            uniq=[]
            for q in pts:
                if not any(np.linalg.norm(q-r)<1e-7 for r in uniq):uniq.append(q)
            if len(uniq)>=2:seg.append((uniq[0],uniq[1]))
    lo,hi=m.bounds();scale=min(1000/max(hi[1]-lo[1],1),650/max(hi[2]-lo[2],1));cy=(hi[1]+lo[1])/2;cz=(hi[2]+lo[2])/2
    lines=''.join(f'<path d="M {600+(q[1]-cy)*scale:.2f} {420-(q[2]-cz)*scale:.2f} L {600+(r[1]-cy)*scale:.2f} {420-(r[2]-cz)*scale:.2f}"/>' for q,r in seg)
    p.write_text(f'<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="860" viewBox="0 0 1200 860"><rect width="1200" height="860" fill="#f5f4ee"/><text x="32" y="40" font-family="sans-serif" font-size="24">{html.escape(a["name"])} · Section A-A / X=0</text><text x="32" y="70" font-family="sans-serif" font-size="15">Exact model-plane intersection · proposed exterior geometry · interior fit not designed</text><g fill="none" stroke="#244b57" stroke-width="1.2">{lines}</g><text x="32" y="823" font-family="sans-serif" font-size="18">Front = −Y. Metres. Source OBJ controls geometry; drawing display scale is automatic.</text></svg>')

def ground_plan(m,a,p):
    z=float(a.get('ground_plan_cut_z_m',1.2));segments=[]
    for part in m.parts:
        for f in part['f']:
            vv=part['v'][list(f)];pts=[]
            for q,r in zip(vv,np.roll(vv,-1,axis=0)):
                if (q[2]-z)*(r[2]-z)<0:pts.append(q+(r-q)*(z-q[2])/(r[2]-q[2]))
                elif abs(q[2]-z)<1e-8:pts.append(q)
            unique=[]
            for q in pts:
                if not any(np.linalg.norm(q-r)<1e-7 for r in unique):unique.append(q)
            if len(unique)>=2:segments.append((unique[0],unique[1]))
    lo,hi=m.bounds();scale=min(1000/max(hi[0]-lo[0],1),630/max(hi[1]-lo[1],1));c=(hi+lo)/2
    lines=''.join(f'<path d="M {600+(q[0]-c[0])*scale:.2f} {425+(q[1]-c[1])*scale:.2f} L {600+(r[0]-c[0])*scale:.2f} {425+(r[1]-c[1])*scale:.2f}"/>' for q,r in segments)
    p.write_text(f'<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="860" viewBox="0 0 1200 860"><rect width="1200" height="860" fill="#f5f4ee"/><text x="32" y="40" font-family="sans-serif" font-size="24">{html.escape(a["name"])} · Ground horizontal section Z={z:.2f} m</text><text x="32" y="70" font-family="sans-serif" font-size="15">Exact exterior model intersection · not a furnished plan or accepted interior enclosure</text><g fill="none" stroke="#244b57" stroke-width="1.2">{lines}</g><text x="32" y="808" font-family="sans-serif" font-size="17">Model bounds {hi[0]-lo[0]:.2f} × {hi[1]-lo[1]:.2f} m. Front −Y points up. No surveyed north.</text><text x="32" y="836" font-family="sans-serif" font-size="15">Interior rooms, entrances, cores and routes still require coordinated shell design.</text></svg>')

BLENDER='''# Run: blender --background --python blender_import.py -- /absolute/output/file.blend [--render]
# Reproducible adapter; not an assertion Blender has executed or engine fit has passed.
import bpy, json, pathlib, sys
from mathutils import Vector
root=pathlib.Path(__file__).resolve().parent
bpy.ops.wm.read_factory_settings(use_empty=True)
bpy.ops.import_scene.gltf(filepath=str(root/'model.glb'))
scene=bpy.context.scene
scene.unit_settings.system='METRIC'
scene.unit_settings.scale_length=1.0
for obj in scene.objects: obj['candidate_status']='PROPOSED; not shell/engine accepted'
scene.render.resolution_x=1200
scene.render.resolution_y=860
scene.render.resolution_percentage=100
scene.render.image_settings.file_format='PNG'
scene.world=bpy.data.worlds.new('Neutral review world')
scene.world.use_nodes=True
scene.world.node_tree.nodes['Background'].inputs[0].default_value=(0.78,0.84,0.86,1)
scene.world.node_tree.nodes['Background'].inputs[1].default_value=0.6
qa=json.loads((root/'QA.json').read_text())
lo,hi=Vector(qa['bounds_m']['min']),Vector(qa['bounds_m']['max'])
span=max(hi-lo)
for name,mult,power in [('Key',(-1,-1,2),1400),('Fill',(1,-0.2,1),800),('Rim',(0,1,1.3),1000)]:
    data=bpy.data.lights.new(name,'AREA');data.energy=power;data.shape='DISK';data.size=span
    obj=bpy.data.objects.new(name,data);scene.collection.objects.link(obj)
    obj.location=(lo+hi)/2+Vector(mult)*span
    obj.rotation_euler=(((lo+hi)/2)-obj.location).to_track_quat('-Z','Y').to_euler()
cameras=json.loads((root/'cameras.json').read_text())['views']
for name,spec in cameras.items():
    data=bpy.data.cameras.new(name);data.type='ORTHO'
    data.ortho_scale=spec.get('ortho_width_m',span*1.55)
    data.clip_start=0.01;data.clip_end=max(1000,span*10)
    obj=bpy.data.objects.new(name,data);scene.collection.objects.link(obj)
    obj.location=spec['position_m'];target=Vector(spec['target_m'])
    obj.rotation_euler=(target-obj.location).to_track_quat('-Z','Y').to_euler()
    obj['source_model_sha256']=qa['model_sha256'];obj['framing']=spec['framing']
scene.camera=bpy.data.objects['hero']
args=sys.argv[sys.argv.index('--')+1:] if '--' in sys.argv else []
output=args[0] if args and not args[0].startswith('--') else str(root/'exterior-candidate.blend')
bpy.ops.wm.save_as_mainfile(filepath=output)
if '--render' in args:
    (root/'blender-renders').mkdir(exist_ok=True)
    for name in cameras:
        scene.camera=bpy.data.objects[name]
        scene.render.filepath=str(root/'blender-renders'/f'{name}.png')
        bpy.ops.render.render(write_still=True)
'''
def generate(a,out):
    if np is None:raise SystemExit('Generation requires numpy; --check needs only Python stdlib.')
    root=out/a['id'];root.mkdir(parents=True,exist_ok=True);(root/'model.json').write_text(json.dumps(a,separators=(',',':'),ensure_ascii=False)+'\n');m=build(a);obj(m,root/'model.obj');gltf(m,root/'model.gltf');cams=cameras(m,a)
    for name,c in cams.items():render(m,a,root/'views'/f'{name}.svg',c,name)
    for name,c in {'roof':{'azimuth_deg':-90,'elevation_deg':90},'front':{'azimuth_deg':-90,'elevation_deg':0},'side':{'azimuth_deg':0,'elevation_deg':0}}.items():render(m,a,root/'plans'/f'{name}.svg',c,f'orthographic {name} (all exterior geometry)')
    ground_plan(m,a,root/'plans'/'ground.svg')
    section(m,a,root/'plans'/'section.svg');(root/'blender_import.py').write_text(BLENDER)
    lo,hi=m.bounds();tris=sum(sum(len(f)-2 for f in p['f']) for p in m.parts);finite=all(np.isfinite(p['v']).all() for p in m.parts);degenerate=sum(np.linalg.norm(np.cross(p['v'][f[1]]-p['v'][f[0]],p['v'][f[2]]-p['v'][f[0]]))<1e-8 for p in m.parts for f in p['f'])
    qa={'schema':'crown-exterior-qa/1','id':a['id'],'name':a['name'],'family':a['family'],'status':'proposed_exterior_candidate','units':'metres','model_axes':{'up':'+Z','front':'-Y','origin':'asset local; no district placement'},'export_axes':{'gltf_up':'+Y','gltf_front':'+Z'},'bounds_m':{'min':lo.tolist(),'max':hi.tolist(),'size':(hi-lo).tolist()},'parts':len(m.parts),'triangles':tris,'finite_vertices':bool(finite),'degenerate_faces':int(degenerate),'proposed':True,'acceptance':{'dimensions':False,'shell':False,'engine':False},'scope':'Exterior candidate only; floorplates/glazing/structural expression are not furnished accessible interiors; no collision/route proof.','model_sha256':sha(root/'model.obj'),'source_refs':a.get('source_refs',[]),'unverified':['Source silhouette alignment requires independent visual review','Proposed dimensions are not surveyed or creator accepted','Interiors, usable openings, core continuity and physical routes','UV maps, textures, LOD/HLOD, collision, navigation and actual engine import'],'test_state':'pass' if finite and not degenerate else 'fail'}
    qa['input_sha256']=sha(root/'model.json');dump(root/'QA.json',qa);dump(root/'cameras.json',{'projection':'orthographic','same_model_sha256':qa['model_sha256'],'source_axes':'Z-up/front−Y','views':cams,'note':'Hero/rear show complete model. Entry/detail are explicit crops and target coordinates of this same model; no accepted opening or route is asserted.'});files=[]
    for p in sorted(root.rglob('*')):
        if p.is_file() and p.name!='MANIFEST.json':files.append({'path':str(p.relative_to(root)),'bytes':p.stat().st_size,'sha256':sha(p)})
    dump(root/'MANIFEST.json',{'id':a['id'],'revision':'R01','status':'proposed_exterior_candidate','files':files})
    print(f'{a["id"]}: {len(m.parts)} parts / {tris} triangles / QA {qa["test_state"]}')
    if qa['test_state']!='pass':raise ValueError(f'{a["id"]} geometry QA failed')

def check(out):
    """Read-only file and geometry check; intentionally no numpy or rendering dependency."""
    manifests=sorted(out.glob('*/MANIFEST.json'));errors=[]
    if not manifests:raise SystemExit('No MANIFEST.json files found')
    for mp in manifests:
        root=mp.parent;manifest=json.loads(mp.read_text());qa=json.loads((root/'QA.json').read_text());listed={x['path']:x for x in manifest['files']};actual={str(p.relative_to(root)) for p in root.rglob('*') if p.is_file() and p.name!='MANIFEST.json' and '__pycache__' not in p.parts}
        if actual!=set(listed):errors.append(f'{root.name}: manifest path coverage differs: {actual^set(listed)}')
        for rel,item in listed.items():
            path=root/rel
            if not path.is_file() or path.stat().st_size!=item['bytes'] or sha(path)!=item['sha256']:errors.append(f'{root.name}: stale file {rel}')
        vertices=[];triangles=0;objects=0
        for line in (root/'model.obj').read_text().splitlines():
            if line.startswith('v '):vertices.append([float(x) for x in line.split()[1:]])
            elif line.startswith('f '):triangles+=len(line.split())-3
            elif line.startswith('o '):objects+=1
        if not vertices or not all(math.isfinite(x) for v in vertices for x in v):errors.append(f'{root.name}: no finite geometry')
        else:
            lo=[min(v[i] for v in vertices) for i in range(3)];hi=[max(v[i] for v in vertices) for i in range(3)]
            if any(abs(lo[i]-qa['bounds_m']['min'][i])>2e-6 or abs(hi[i]-qa['bounds_m']['max'][i])>2e-6 for i in range(3)):errors.append(f'{root.name}: actual OBJ bounds differ')
        if triangles!=qa['triangles'] or objects!=qa['parts']:errors.append(f'{root.name}: geometry counts differ')
        if sha(root/'model.obj')!=qa['model_sha256'] or sha(root/'model.json')!=qa['input_sha256']:errors.append(f'{root.name}: model/input pin differs')
        raw=(root/'model.glb').read_bytes();magic,version,length=struct.unpack('<III',raw[:12])
        if (magic,version,length)!=(0x46546c67,2,len(raw)):errors.append(f'{root.name}: bad GLB header')
        if qa['acceptance']!={'dimensions':False,'shell':False,'engine':False}:errors.append(f'{root.name}: unsupported acceptance claim')
        if qa['test_state']!='pass' or qa['degenerate_faces']!=0:errors.append(f'{root.name}: failed generation QA')
    if errors:raise SystemExit('\n'.join(errors))
    print(f'PASS: {len(manifests)} exterior candidate manifests, actual OBJ bounds/counts, input/model pins and GLB headers (stdlib-only read-only check).')

def main():
    ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--input',type=Path);ap.add_argument('--out',type=Path,required=True);ap.add_argument('--check',action='store_true');args=ap.parse_args()
    if args.check:check(args.out);return
    if not args.input:ap.error('--input is required for generation')
    data=json.loads(args.input.read_text());assets=data.get('assets',[data]);
    for a in assets:generate(a,args.out)
if __name__=='__main__':main()
