abelien-harness 0.4.0 → 0.6.0

package/skills/abelien-structure/worker/component-target-image.d.mts

@@ -0,0 +1,23 @@
+import type {ComponentFitBinding} from './component-fit.mjs';
+export interface TargetImageProvenance {
+  schema: 'abelien.appearance-target-image.v1';
+  baseline: ComponentFitBinding;
+  targetGlbSha256: string;
+  targetNodeNames: string[];
+  targetWorldMatrix: number[];
+  triangleCount: number;
+  imageSha256?: string;
+  rendererSha256?: string;
+  view?: {preset: 'isometric'; elevationDeg: 25; azimuthDeg: -55; size: 640; basis: 'gltf_y_up_to_render_z_up'; appearance: 'diffuse_base_color'};
+}
+/** Input baseline is server-resolved current owned draft; does not independently authorize ownership. */
+export function extractTargetComponent(input: {baseline: ComponentFitBinding; baselineGlb: Uint8Array}): {targetGlb: Buffer; provenance: TargetImageProvenance};
+/** Private trusted-host diagnostics; never part of a public asset or user-facing error. */
+export interface TargetRenderDiagnostic {
+  schema: 'abelien.appearance-target-render-diagnostic.v1'; baseline: ComponentFitBinding; rendererSha256: string;
+  durationMs: number; status: 'succeeded'|'failed'; exitCode: number|null; signal: string|null;
+  stderr: string; stderrBytes: number; stderrTruncated: boolean;
+  error: {code:string;name:string;message:string;stack?:string}|null;
+}
+/** Administrator-selected absolute executable path; no model/browser path input, no silent fallback. */
+export function renderTargetComponentImage(input: {baseline: ComponentFitBinding; baselineGlb: Uint8Array}, options: {pythonPath: string; signal?: AbortSignal; onDiagnostic?: (event: TargetRenderDiagnostic)=>void}): Promise<{targetGlb: Buffer; png: Buffer; provenance: TargetImageProvenance}>;

package/skills/abelien-structure/worker/component-target-image.mjs

@@ -0,0 +1,107 @@
+/** Trusted same-baseline target-only extraction and actual fixed-camera raster rendering. */
+import {spawn} from 'node:child_process';
+import {mkdtemp,readFile,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {encodeGlb,fail,MAX_GLB_BYTES,parseGlb,sha256,triangles} from './component-fit-glb.mjs';
+const here=path.dirname(fileURLToPath(import.meta.url));
+const textureInfos=material=>[material.pbrMetallicRoughness?.baseColorTexture,material.pbrMetallicRoughness?.metallicRoughnessTexture,material.normalTexture,material.occlusionTexture,material.emissiveTexture].filter(Boolean);
+const components={SCALAR:1,VEC2:2,VEC3:3,VEC4:4,MAT2:4,MAT3:9,MAT4:16},bytes={5120:1,5121:1,5122:2,5123:2,5125:4,5126:4};
+
+export function extractTargetComponent({baseline,baselineGlb}){
+  if(!baseline||typeof baseline.draftId!=='string'||!baseline.draftId||typeof baseline.baselineId!=='string'||!baseline.baselineId||!Number.isSafeInteger(baseline.baselineRevision)||baseline.baselineRevision<0||typeof baseline.targetOccurrenceId!=='string'||!baseline.targetOccurrenceId||!(baselineGlb instanceof Uint8Array)||baselineGlb.byteLength>MAX_GLB_BYTES||sha256(baselineGlb)!==baseline.baselineGlbSha256)fail('invalid_target_image_baseline');
+  const parsed=parseGlb(baselineGlb),source=parsed.doc;
+  const matches=source.nodes.flatMap((node,index)=>node.name===baseline.targetOccurrenceId?[index]:[]);
+  if(matches.length!==1)fail('missing_or_ambiguous_target_image_node');
+  const target=matches[0],selected=[];
+  const visit=index=>{selected.push(index);for(const child of source.nodes[index].children??[])visit(child);};visit(target);
+  const mapping=new Map(selected.map((index,next)=>[index,next]));
+  const doc={asset:structuredClone(source.asset),scene:0,scenes:[{nodes:[0]}],nodes:[],meshes:[],accessors:[],bufferViews:[],materials:[],textures:[],images:[],samplers:[],buffers:[{byteLength:0}]};
+  const chunks=[],maps=Object.fromEntries(['meshes','accessors','materials','textures','images','samplers'].map(key=>[key,new Map()]));let length=0,triangleCount=0;
+  const appendView=buffer=>{
+    const padding=(4-length%4)%4;if(padding){chunks.push(Buffer.alloc(padding));length+=padding;}
+    const index=doc.bufferViews.length;doc.bufferViews.push({buffer:0,byteOffset:length,byteLength:buffer.length});chunks.push(buffer);length+=buffer.length;return index;
+  };
+  const copyResource=(key,index)=>{
+    if(maps[key].has(index))return maps[key].get(index);
+    const next=doc[key].length,row=structuredClone(source[key][index]);maps[key].set(index,next);doc[key].push(row);
+    if(key==='meshes')for(const primitive of row.primitives){
+      for(const attribute of Object.keys(primitive.attributes))primitive.attributes[attribute]=copyResource('accessors',primitive.attributes[attribute]);
+      if(primitive.indices!==undefined)primitive.indices=copyResource('accessors',primitive.indices);
+      if(primitive.material!==undefined)primitive.material=copyResource('materials',primitive.material);
+    }else if(key==='accessors'){
+      const view=source.bufferViews[row.bufferView],itemBytes=components[row.type]*bytes[row.componentType],stride=view.byteStride??itemBytes,offset=(view.byteOffset??0)+(row.byteOffset??0),buffer=Buffer.alloc(row.count*itemBytes);
+      for(let i=0;i<row.count;i++)parsed.bin.copy(buffer,i*itemBytes,offset+i*stride,offset+i*stride+itemBytes);
+      row.bufferView=appendView(buffer);delete row.byteOffset;
+    }else if(key==='materials')for(const texture of textureInfos(row))texture.index=copyResource('textures',texture.index);
+    else if(key==='textures'){row.source=copyResource('images',row.source);if(row.sampler!==undefined)row.sampler=copyResource('samplers',row.sampler);}
+    else if(key==='images'){const view=source.bufferViews[row.bufferView];row.bufferView=appendView(Buffer.from(parsed.bin.subarray(view.byteOffset??0,(view.byteOffset??0)+view.byteLength)));}
+    return next;
+  };
+  for(const index of selected){
+    const node=structuredClone(source.nodes[index]);if(node.mesh!==undefined)node.mesh=copyResource('meshes',node.mesh);
+    if(node.children)node.children=node.children.map(child=>mapping.get(child));
+    if(index===target){delete node.translation;delete node.rotation;delete node.scale;node.matrix=[...parsed.world.get(target)];}
+    doc.nodes.push(node);
+    for(const _ of triangles(parsed,index,parsed.world.get(index)))if(++triangleCount>200000)fail('target_image_geometry_too_large');
+  }
+  if(!triangleCount)fail('target_image_has_no_geometry');
+  for(const key of ['extensionsUsed','extensionsRequired'])if(source[key])doc[key]=structuredClone(source[key]);
+  for(const key of ['materials','textures','images','samplers'])if(!doc[key].length)delete doc[key];
+  doc.buffers[0].byteLength=length;
+  const targetGlb=encodeGlb(doc,Buffer.concat(chunks));parseGlb(targetGlb);
+  return {targetGlb,provenance:{schema:'abelien.appearance-target-image.v1',baseline:structuredClone(baseline),targetGlbSha256:sha256(targetGlb),targetNodeNames:selected.map(index=>source.nodes[index].name??`node:${index}`),targetWorldMatrix:[...parsed.world.get(target)],triangleCount}};
+}
+function renderMeshes(targetGlb){
+  const parsed=parseGlb(targetGlb),mesh=[];
+  for(let index=0;index<parsed.doc.nodes.length;index++){
+    const node=parsed.doc.nodes[index];if(node.mesh===undefined)continue;
+    for(const primitive of parsed.doc.meshes[node.mesh].primitives){
+      const material=parsed.doc.materials?.[primitive.material]??{},pbr=material.pbrMetallicRoughness??{},color=pbr.baseColorFactor??[1,1,1,1];
+      if(textureInfos(material).length||primitive.attributes.COLOR_0!==undefined||material.extensions?.KHR_materials_unlit||(material.alphaMode??'OPAQUE')!=='OPAQUE'||(material.emissiveFactor??[0,0,0]).some(value=>value!==0)||!Array.isArray(color)||color.length!==4||color.some(value=>!Number.isFinite(value)||value<0||value>1)||color[3]!==1)fail('target_renderer_appearance_unsupported');
+      const isolated={...parsed,doc:{...parsed.doc,meshes:[{primitives:[primitive]}],nodes:[{mesh:0}]}};
+      const values=[...triangles(isolated,0,parsed.world.get(index))].map(triangle=>triangle.map(([x,y,z])=>[x*1000,-z*1000,y*1000]));
+      const hex='#'+color.slice(0,3).map(linear=>Math.round((linear<=0.0031308?12.92*linear:1.055*linear**(1/2.4)-0.055)*255).toString(16).padStart(2,'0')).join('');
+      mesh.push({occurrenceId:node.name??`target-${index}`,color:hex,triangles:values});
+    }
+  }
+  return mesh;
+}
+export async function renderTargetComponentImage(input,{pythonPath,signal,onDiagnostic}={}){
+  if(!path.isAbsolute(pythonPath??'')||/[\x00-\x1f]/.test(pythonPath??''))fail('target_renderer_unavailable');
+  if(signal?.aborted)fail('target_renderer_aborted');
+  const extracted=extractTargetComponent(input),meshes=renderMeshes(extracted.targetGlb);
+  const script=path.join(here,'component-target-render.py'),renderer=path.join(here,'cad.py');
+  const rendererSha256=sha256(Buffer.concat([await readFile(script),await readFile(renderer)]));
+  const body=Buffer.from(JSON.stringify({meshes}));if(body.length>32*1024*1024)fail('target_image_geometry_too_large');
+  const root=await mkdtemp(path.join(tmpdir(),'abelien-target-render-'));
+  try{
+    const output=await new Promise((resolve,reject)=>{
+      const child=spawn(pythonPath,['-I','-B',script],{cwd:root,env:{PATH:'/usr/bin:/bin',LANG:'en_US.UTF-8',MPLBACKEND:'Agg',MPLCONFIGDIR:root,HOME:root,TMPDIR:root,OPENBLAS_NUM_THREADS:'1',OMP_NUM_THREADS:'1',VECLIB_MAXIMUM_THREADS:'1'},stdio:['pipe','pipe','pipe']});
+      const chunks=[],started=performance.now();let size=0,settled=false,stderr=Buffer.alloc(0),stderrBytes=0;
+      // Private process diagnostics retain the tail so a Python traceback survives verbose warnings.
+      // The child receives only a fixed credential-free environment and numeric mesh data.
+      const end=(code,value,details={})=>{if(settled)return;settled=true;clearTimeout(timer);signal?.removeEventListener('abort',abort);
+        const error=code?Object.assign(new Error(code),{code}):null;
+        const normalizedStderr=Buffer.from(stderr.toString('utf8'));
+        const diagnostic={schema:'abelien.appearance-target-render-diagnostic.v1',baseline:structuredClone(input.baseline),rendererSha256,
+          durationMs:performance.now()-started,status:code?'failed':'succeeded',exitCode:details.exitCode??null,signal:details.signal??null,
+          stderr:normalizedStderr.subarray(Math.max(0,normalizedStderr.length-65532)).toString('utf8'),stderrBytes,stderrTruncated:stderrBytes>stderr.length||normalizedStderr.length>65532,
+          error:code?{code,name:details.error?.name??error.name,message:details.error?.message??error.message,stack:details.error?.stack??error.stack}:null};
+        try{const observed=onDiagnostic?.(diagnostic);observed?.catch?.(()=>{});}catch{/* diagnostics must not alter render state */}
+        if(error){child.kill('SIGKILL');reject(error);}else resolve(value);};
+      const abort=()=>end('target_renderer_aborted'),timer=setTimeout(()=>end('target_renderer_timeout'),60000);
+      signal?.addEventListener('abort',abort,{once:true});if(signal?.aborted)abort();
+      child.once('error',error=>end('target_renderer_unavailable',undefined,{error}));child.stdin.on('error',error=>end('target_renderer_failed',undefined,{error}));
+      child.stderr.on('data',chunk=>{stderrBytes+=chunk.length;stderr=Buffer.concat([stderr,chunk]);if(stderr.length>65536)stderr=stderr.subarray(stderr.length-65536);});
+      child.stdout.on('data',chunk=>{size+=chunk.length;if(size>5*1024*1024)end('target_renderer_output_too_large');else chunks.push(chunk);});
+      child.once('close',(code,exitSignal)=>end(code===0?null:'target_renderer_failed',Buffer.concat(chunks),{exitCode:code,signal:exitSignal}));child.stdin.end(body);
+    });
+    let result;try{result=JSON.parse(output.toString('utf8'));}catch{fail('target_renderer_invalid_output');}
+    if(result.rendererSha256!==rendererSha256)fail('target_renderer_source_drift');
+    const png=Buffer.from(result.png??'','base64');
+    if(!png.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10]))||png.length<33||png.readUInt32BE(16)!==640||png.readUInt32BE(20)!==640)fail('target_renderer_invalid_output');
+    return {...extracted,png,provenance:{...extracted.provenance,imageSha256:sha256(png),rendererSha256,view:{preset:'isometric',elevationDeg:25,azimuthDeg:-55,size:640,basis:'gltf_y_up_to_render_z_up',appearance:'diffuse_base_color'}}};
+  }finally{await rm(root,{recursive:true,force:true});}
+}

package/skills/abelien-structure/worker/component-target-render.py

@@ -0,0 +1,58 @@
+"""Data-only local target rasterizer; reuse the trusted Worker render_scene function."""
+import ast
+import base64
+import hashlib
+import json
+import math
+from pathlib import Path
+import sys
+import traceback
+
+
+def main():
+    import numpy as np
+    import matplotlib
+    matplotlib.use('Agg')
+    import matplotlib.pyplot as plt
+
+    source_path = Path(__file__).with_name('cad.py')
+    source_bytes = source_path.read_bytes()
+    source = source_bytes.decode('utf-8')
+    renderer_sha256 = hashlib.sha256(Path(__file__).read_bytes() + source_bytes).hexdigest()
+    functions = [item for item in ast.parse(source).body if isinstance(item, ast.FunctionDef) and item.name == 'render_scene']
+    if len(functions) != 1:
+        raise ValueError('renderer_unavailable')
+    # Do not import cad.py: its top-level consumes a modeling request. Only the
+    # reviewed renderer function is compiled, with fixed numeric/image globals.
+    namespace = {'np': np, 'plt': plt, 'math': math, 'hashlib': hashlib}
+    exec(compile(ast.Module(body=functions, type_ignores=[]), str(source_path), 'exec'), namespace)
+    raw = sys.stdin.buffer.read(32 * 1024 * 1024 + 1)
+    if len(raw) > 32 * 1024 * 1024:
+        raise ValueError('geometry_too_large')
+    request = json.loads(raw)
+    mesh = []
+    count = 0
+    for item in request['meshes']:
+        triangles = np.asarray(item['triangles'], dtype=np.float64)
+        if triangles.ndim != 3 or triangles.shape[1:] != (3, 3) or not np.isfinite(triangles).all():
+            raise ValueError('invalid_triangles')
+        count += len(triangles)
+        if count > 200000:
+            raise ValueError('geometry_too_large')
+        color = item['color']
+        if not isinstance(color, str) or len(color) != 7 or color[0] != '#' or any(ch not in '0123456789abcdef' for ch in color[1:]):
+            raise ValueError('invalid_color')
+        occurrence = {'occurrenceId': item['occurrenceId'], 'bomItemId': None, 'material': {'baseColorSrgb': color}}
+        mesh.append((occurrence, triangles, tuple(triangles.reshape(-1, 3).mean(axis=0))))
+    if not count:
+        raise ValueError('empty_geometry')
+    png = namespace['render_scene'](Path.cwd(), 'target', mesh, 25, -55)
+    print(json.dumps({'png': base64.b64encode(png).decode('ascii'), 'rendererSha256': renderer_sha256}, separators=(',', ':')))
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except Exception:
+        traceback.print_exc(file=sys.stderr)
+        raise SystemExit(1)

package/skills/abelien-structure/worker/config.mjs

@@ -0,0 +1,6 @@
+/** Shared local defaults for the Structure Worker and its low-level native helper. */
+export const DEFAULT_STRUCTURE_PORT = 16424;
+
+export function structureLoopbackOrigin(env = process.env) {
+  return env.AGENT_STRUCTURE_ORIGIN ?? `http://127.0.0.1:${DEFAULT_STRUCTURE_PORT}`;
+}

package/skills/abelien-structure/worker/engineering-fit.d.mts

@@ -0,0 +1,48 @@
+export type EngineeringJson = null | boolean | number | string | EngineeringJson[] | { [key: string]: EngineeringJson };
+export interface EngineeringProposal {
+ schema: 'abelien.planar-attachment-proposal.v1'; targetOccurrenceId: string; baseOccurrenceId: string;
+ plate: { widthMm: number; depthMm: number; thicknessMm: number; holeRadiusMm: number; holeCentersMm: [number,number][] };
+ baseThicknessMm: number; decoration: { heightMm: number; maximumWidthMm: number; maximumDepthMm: number; trimBottomFraction: number };
+ join: { radiusMm: number; embedMm: number; gapMm: number }; clearanceMm: number;
+}
+export interface EngineeringBaselineIdentity { sourceSha256: string; modelStepSha256: string; assemblySha256: string; occurrenceSetSha256: string; attachmentSha256: string; targetGeometrySha256: string; targetTransformSha256: string }
+export interface AttachmentBaseline extends EngineeringBaselineIdentity {
+ schema: 'abelien.planar-attachment-baseline.v1'; checkerVersion: 'planar-two-hole-fit.v1';
+ asModeledOnlyOccurrenceIds:string[]; policy: Record<string,EngineeringJson>; proposal: EngineeringProposal; checks: Record<string,EngineeringJson>;
+}
+export interface EngineeringRecipe {
+ schema: 'abelien.component-engineering-recipe.v1'; checkerVersion: 'planar-two-hole-fit.v1'; policy: Record<string,EngineeringJson>;
+ baseline: EngineeringBaselineIdentity; targetOccurrenceId: string; candidateGlbSha256: string;
+ decorationGlbSha256:string; repair:EngineeringRepair;
+ placement: { method: 'declared_design_height'; sourceUnits: 'unknown'; scaleMmPerSourceUnit: number; translationMm: number[]; trimBottomMm: number; cutZMm: number; heightBeforeTrimMm: number };
+}
+export interface EngineeringFitReport {
+ schema: 'abelien.component-engineering-fit-report.v1'; checkerVersion: 'planar-two-hole-fit.v1'; policy: Record<string,EngineeringJson>;
+ representation: 'analytic_carrier_faceted_decoration'; scope: 'planar_two_hole_solid_decoration.v1'; fitStatus: 'pass'; adoptionEligible: true;
+ baseline: EngineeringBaselineIdentity; targetOccurrenceId: string; candidateGlbSha256: string; recipeSha256: string; modelStepSha256: string; modelGlbSha256: string; assemblySha256: string;
+ asModeledOnlyOccurrenceIds:string[]; decorationGlbSha256:string; repair:EngineeringRepair;
+ subject: {sourceSha256:string;modelStepSha256:string;modelGlbSha256:string;assemblySha256:string;occurrenceSetSha256:string};
+ checks: {id:string;status:'pass';method:'occt_brep_independent_readback';measured:Record<string,EngineeringJson>}[];
+ notChecked: string[]; decorationShellWall: { status:'not_applicable'; reason:'filled_decoration_no_cavity' };
+}
+export interface EngineeringFitRequest {
+ operation:'component_fit';key:string;basis:string;title:string;pass:'final';
+ fit:{priorJobId:string;priorSubject:{sourceSha256:string;assemblySha256:string;occurrenceSetSha256:string};attachmentSha256:string;candidateGlb:{sha256:string;base64:string}};
+}
+export const ENGINEERING_VERSION:'planar-two-hole-fit.v1';
+export const ENGINEERING_MAX_BODY_BYTES:number;
+export const ENGINEERING_ARTIFACT_TYPES:Readonly<Record<string,string>>;
+export const ENGINEERING_CHECKS:readonly string[];
+export const ENGINEERING_NOT_CHECKED:readonly string[];
+export function normalizeEngineeringFitRequest(input:unknown):{input:EngineeringFitRequest;triangles:number[][][]};
+/** Caller must obtain assembly/STEP from the same trusted worker/baseline job. */
+export function validateAttachmentBaseline(value:unknown,assembly:unknown,step:Uint8Array):AttachmentBaseline;
+/** Byte/identity verifier; geometric truth comes from the pinned fresh native STEP checker. */
+export function validateEngineeringArtifacts<T>(files:Map<string,Uint8Array>,expected:{attachment:AttachmentBaseline;assembly:T;candidateGlbSha256:string}):{report:EngineeringFitReport;recipe:EngineeringRecipe;assembly:T};
+
+export const ENGINEERING_POLICY:Readonly<Record<string,EngineeringJson>>;
+export function validateEngineeringStoredArtifacts<T>(files:Map<string,Uint8Array>,expected:{attachment:AttachmentBaseline;assembly:T;candidateGlbSha256:string}):{report:EngineeringFitReport;recipe:EngineeringRecipe;assembly:T};
+
+export interface EngineeringRepair {
+ status:'not_needed'|'applied';method:'none'|'bounded_local_laplacian';originalGlbSha256:string;derivedGlbSha256:string;topologySha256:string;topologyBinding:'identical_bytes'|'all_non_position_bytes';iterations:number;originalInterferenceCount:number;remainingInterferenceCount:0;uniqueVertexCount:number;changedVertexCount:number;changedVertexFraction:number;maximumDisplacementMm:number;rmsDisplacementMm:number;signedVolumeRelativeChange:number;boundsMaximumChangeMm:number;movedVertexIds:number[];
+}

package/skills/abelien-structure/worker/engineering-fit.mjs

@@ -0,0 +1,118 @@
+/** Strict server-only engineering transport/artifact identity; kernel supplies geometric proof. */
+import engineeringPolicy from './engineering-policy.json' with {type:'json'};
+import {validateAssemblyEvidence} from './assembly-validation.mjs';
+import {parseGlb,triangles,sha256} from './component-fit-glb.mjs';
+import {manifestHash} from './manifest-digest.mjs';
+export const ENGINEERING_VERSION='planar-two-hole-fit.v1';
+export const ENGINEERING_POLICY=Object.freeze(engineeringPolicy);
+export const ENGINEERING_MAX_BODY_BYTES=8*1024*1024;
+export const ENGINEERING_ARTIFACT_TYPES=Object.freeze({'model.step':'model/step','model.glb':'model/gltf-binary','decoration.glb':'model/gltf-binary',
+  'front.png':'image/png','top.png':'image/png','iso.png':'image/png','normal.png':'image/png','internal.png':'image/png','exploded.png':'image/png',
+  'assembly.json':'application/json','fit.json':'application/json','recipe.json':'application/json'});
+export const ENGINEERING_CHECKS=Object.freeze(['baseline','closed_solid','self_intersection','carrier_preservation','interface_surfaces','protected_regions','continuous_join','static_collision','clearance','planar_insertion','preserved_occurrences','step_readback']);
+export const ENGINEERING_NOT_CHECKED=Object.freeze(['strength','manufacturability','physical_assembly','local_thin_features','texture_fidelity','hardware_geometry_accuracy']);
+const HEX=/^[a-f0-9]{64}$/,UUID=/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/;
+const fail=()=>{throw Object.assign(new Error('invalid_engineering_artifact'),{code:'invalid_input'});};
+const keys=(v,n)=>v&&typeof v==='object'&&!Array.isArray(v)&&Object.keys(v).length===n.length&&n.every(k=>Object.hasOwn(v,k));
+const same=(a,b)=>manifestHash(a)===manifestHash(b);
+export function normalizeEngineeringFitRequest(input){
+  if(!keys(input,['operation','key','basis','title','pass','fit'])||input.operation!=='component_fit'||input.pass!=='final'||!HEX.test(input.key??'')||!HEX.test(input.basis??'')||typeof input.title!=='string'||!input.title.trim()||input.title.length>100)fail();
+  const f=input.fit;
+  if(!keys(f,['priorJobId','priorSubject','attachmentSha256','candidateGlb'])||!UUID.test(f.priorJobId??'')||!HEX.test(f.attachmentSha256??'')||
+    !keys(f.priorSubject,['sourceSha256','assemblySha256','occurrenceSetSha256'])||Object.values(f.priorSubject).some(v=>!HEX.test(v??''))||
+    !keys(f.candidateGlb,['sha256','base64'])||!HEX.test(f.candidateGlb.sha256??'')||typeof f.candidateGlb.base64!=='string'||f.candidateGlb.base64.length>ENGINEERING_MAX_BODY_BYTES-65536)fail();
+  const bytes=Buffer.from(f.candidateGlb.base64,'base64');if(!bytes.length||bytes.toString('base64')!==f.candidateGlb.base64||sha256(bytes)!==f.candidateGlb.sha256)fail();
+  const parsed=parseGlb(bytes),faces=[];
+  if((parsed.doc.textures??[]).length||(parsed.doc.images??[]).length)fail();
+  for(const [node,matrix] of parsed.world){
+    for(const triangle of triangles(parsed,node,matrix)){faces.push(triangle);if(faces.length>ENGINEERING_POLICY.maximumTriangles)fail();}
+  }
+  if(faces.length<4)fail();
+  return {input:structuredClone(input),triangles:faces};
+}
+export function validateAttachmentBaseline(value,assembly,step){
+  if(!keys(value,['schema','checkerVersion','policy','proposal','sourceSha256','modelStepSha256','assemblySha256','occurrenceSetSha256','targetGeometrySha256','targetTransformSha256','asModeledOnlyOccurrenceIds','checks','attachmentSha256'])||
+    value.schema!=='abelien.planar-attachment-baseline.v1'||value.checkerVersion!==ENGINEERING_VERSION||!same(value.policy,ENGINEERING_POLICY)||
+    value.sourceSha256!==assembly.sourceSha256||value.modelStepSha256!==sha256(step)||value.assemblySha256!==assembly.assemblySha256||value.occurrenceSetSha256!==assembly.occurrenceSetSha256)fail();
+  if(!same(value.asModeledOnlyOccurrenceIds,assembly.occurrences.filter(o=>o.geometryPrecision==='envelope').map(o=>o.occurrenceId)))fail();
+  const target=assembly.occurrences.find(o=>o.occurrenceId===value.proposal?.targetOccurrenceId);
+  if(!target||target.geometrySha256!==value.targetGeometrySha256||target.transformSha256!==value.targetTransformSha256||value.checks?.staticCollision!=='pass'||value.checks?.planarInsertion!=='pass')fail();
+  const measured=value.checks;
+  if(!measured||!withinVolume(measured.carrierSymmetricDifferenceMm3)||!withinVolume(measured.baseSymmetricDifferenceMm3)||!validInterfaces(measured.interfaces,value.proposal.plate))fail();
+  const unsigned={...value};delete unsigned.attachmentSha256;if(value.attachmentSha256!==manifestHash(unsigned))fail();
+  return value;
+}
+const STORED_NAMES=Object.freeze(Object.keys(ENGINEERING_ARTIFACT_TYPES).filter(n=>!['front.png','top.png','iso.png'].includes(n)));
+export function validateEngineeringArtifacts(files,expected){return validateFiles(files,expected,Object.keys(ENGINEERING_ARTIFACT_TYPES));}
+export function validateEngineeringStoredArtifacts(files,expected){return validateFiles(files,expected,STORED_NAMES);}
+const finite=v=>typeof v==='number'&&Number.isFinite(v);
+const withinVolume=v=>finite(v)&&v>=0&&v<=ENGINEERING_POLICY.volumeToleranceMm3;
+const near=(a,b)=>finite(a)&&finite(b)&&Math.abs(a-b)<=ENGINEERING_POLICY.linearToleranceMm;
+function validInterfaces(value,p){
+ if(!keys(value,['holes','seatAreaMm2'])||!Array.isArray(value.holes)||value.holes.length!==2||!near(value.seatAreaMm2,p.widthMm*p.depthMm-2*Math.PI*p.holeRadiusMm**2))return false;
+ return value.holes.every((h,i)=>keys(h,['center','radius','zMin','zMax'])&&Array.isArray(h.center)&&h.center.length===2&&h.center.every((v,k)=>near(v,p.holeCentersMm[i][k]))&&near(h.radius,p.holeRadiusMm)&&near(h.zMin,0)&&near(h.zMax,p.thicknessMm));
+}
+function validateMeasurements(report,expected){
+ const m=report.checks.map(c=>c.measured),p=expected.attachment.proposal;
+ const ids=expected.assembly.occurrences.filter(o=>o.occurrenceId!==p.targetOccurrenceId).map(o=>o.occurrenceId);
+ const pairs=(v,field,check)=>Array.isArray(v)&&v.length===ids.length&&v.every((row,i)=>keys(row,['occurrenceId',field])&&row.occurrenceId===ids[i]&&check(row[field]));
+ if(!same(m[0],{validatedAttachmentSha256:expected.attachment.attachmentSha256})||!same(m[1],{solidCount:1,shellCount:1})||!same(m[2],{interferenceCount:0})||
+ !keys(m[3],['lostVolumeMm3'])||!withinVolume(m[3].lostVolumeMm3)||!validInterfaces(m[4],p.plate)||
+ !keys(m[5],['symmetricDifferenceMm3','holeObstructionMm3','seatDifferenceMm3'])||!['symmetricDifferenceMm3','holeObstructionMm3'].every(k=>Array.isArray(m[5][k])&&m[5][k].length===2&&m[5][k].every(withinVolume))||!withinVolume(m[5].seatDifferenceMm3)||
+ !keys(m[6],['missingWitnessMm3','radiusMm','sectionAreaMm2','embedMm'])||!withinVolume(m[6].missingWitnessMm3)||!near(m[6].radiusMm,p.join.radiusMm)||!near(m[6].sectionAreaMm2,Math.PI*p.join.radiusMm**2)||!near(m[6].embedMm,p.join.embedMm)||
+ !keys(m[7],['pairs'])||!pairs(m[7].pairs,'overlapMm3',withinVolume)||!keys(m[8],['minimumRequiredMm','pairs'])||m[8].minimumRequiredMm!==p.clearanceMm||!pairs(m[8].pairs,'distanceMm',v=>finite(v)&&v+ENGINEERING_POLICY.linearToleranceMm>=p.clearanceMm)||
+ !same(m[9],{method:'brep_separating_halfspaces',outwardLocal:[0,0,1]})||!keys(m[10],['occurrences'])||!pairs(m[10].occurrences,'symmetricDifferenceMm3',withinVolume)||
+ !keys(m[11],['compositionSymmetricDifferenceMm3','solidCount'])||!withinVolume(m[11].compositionSymmetricDifferenceMm3)||m[11].solidCount!==expected.assembly.occurrenceCount)fail();
+}
+function validateRepair(r,originalSha,derivedSha,height){
+ const fields=['status','method','originalGlbSha256','derivedGlbSha256','topologySha256','topologyBinding','iterations','originalInterferenceCount','remainingInterferenceCount','uniqueVertexCount','changedVertexCount','changedVertexFraction','maximumDisplacementMm','rmsDisplacementMm','signedVolumeRelativeChange','boundsMaximumChangeMm','movedVertexIds'];
+ if(!keys(r,fields)||r.originalGlbSha256!==originalSha||r.derivedGlbSha256!==derivedSha||!HEX.test(r.topologySha256??'')||r.remainingInterferenceCount!==0||!Number.isSafeInteger(r.uniqueVertexCount)||r.uniqueVertexCount<4||!Array.isArray(r.movedVertexIds)||r.movedVertexIds.length!==r.changedVertexCount||new Set(r.movedVertexIds).size!==r.movedVertexIds.length||r.movedVertexIds.some(i=>!Number.isSafeInteger(i)||i<0||i>=r.uniqueVertexCount)||r.changedVertexFraction!==r.changedVertexCount/r.uniqueVertexCount)fail();
+ const metrics=['maximumDisplacementMm','rmsDisplacementMm','signedVolumeRelativeChange','boundsMaximumChangeMm'];
+ if(metrics.some(k=>!finite(r[k])||r[k]<0))fail();
+ const rule=ENGINEERING_POLICY.repair,max=Math.min(rule.maximumDisplacementMm,height*rule.maximumHeightFraction);
+ if(r.status==='not_needed'){
+  if(r.method!=='none'||r.topologyBinding!=='identical_bytes'||r.topologySha256!==originalSha||originalSha!==derivedSha||r.iterations!==0||r.originalInterferenceCount!==0||r.changedVertexCount!==0||metrics.some(k=>r[k]!==0))fail();
+ }else if(r.status==='applied'){
+  if(r.method!=='bounded_local_laplacian'||r.topologyBinding!=='all_non_position_bytes'||r.iterations!==rule.maximumIterations||!Number.isSafeInteger(r.originalInterferenceCount)||r.originalInterferenceCount<1||r.changedVertexCount<1||r.changedVertexFraction>rule.maximumVertexFraction||r.maximumDisplacementMm>max||r.rmsDisplacementMm>r.maximumDisplacementMm||r.boundsMaximumChangeMm>r.maximumDisplacementMm+ENGINEERING_POLICY.linearToleranceMm||r.signedVolumeRelativeChange>rule.maximumSignedVolumeRelativeChange)fail();
+ }else fail();
+}
+function validateFiles(files,expected,names){
+ if(!(files instanceof Map)||files.size!==names.length||names.some(n=>!files.has(n)))fail();
+ files=new Map([...files].map(([name,body])=>{
+  if(!(body instanceof Uint8Array)||!body.byteLength||body.byteLength>(name.endsWith('.png')?4*1024*1024:name.endsWith('.json')?128*1024:24*1024*1024))fail();
+  const value=Buffer.from(body);
+  if(name.endsWith('.png')&&!value.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])))fail();
+  if(name.endsWith('.step')&&!value.subarray(0,128).toString().includes('ISO-10303-21'))fail();
+  if(name.endsWith('.glb'))parseGlb(value);
+  return [name,value];
+ }));
+  const report=JSON.parse(files.get('fit.json')),recipe=JSON.parse(files.get('recipe.json')),assembly=JSON.parse(files.get('assembly.json'));
+  const a=expected.attachment,baseline=Object.fromEntries(['sourceSha256','modelStepSha256','assemblySha256','occurrenceSetSha256','attachmentSha256','targetGeometrySha256','targetTransformSha256'].map(k=>[k,a[k]]));
+  if(!keys(report,['schema','checkerVersion','policy','representation','scope','fitStatus','adoptionEligible','baseline','targetOccurrenceId','candidateGlbSha256','recipeSha256','modelStepSha256','modelGlbSha256','assemblySha256','subject','asModeledOnlyOccurrenceIds','repair','decorationGlbSha256','checks','notChecked','decorationShellWall'])||!same(report.policy,ENGINEERING_POLICY)||report.schema!=='abelien.component-engineering-fit-report.v1'||report.checkerVersion!==ENGINEERING_VERSION||report.scope!=='planar_two_hole_solid_decoration.v1'||
+    report.representation!=='analytic_carrier_faceted_decoration'||report.fitStatus!=='pass'||report.adoptionEligible!==true||!same(report.baseline,baseline)||
+    report.targetOccurrenceId!==a.proposal.targetOccurrenceId||report.candidateGlbSha256!==expected.candidateGlbSha256||report.recipeSha256!==sha256(files.get('recipe.json'))||
+    report.modelStepSha256!==sha256(files.get('model.step'))||report.modelGlbSha256!==sha256(files.get('model.glb'))||report.assemblySha256!==assembly.assemblySha256||
+    !same(report.notChecked,ENGINEERING_NOT_CHECKED)||!same(report.decorationShellWall,{status:'not_applicable',reason:'filled_decoration_no_cavity'})||!Array.isArray(report.checks)||report.checks.length!==ENGINEERING_CHECKS.length||
+    report.checks.some((c,i)=>!keys(c,['id','status','method','measured'])||c.id!==ENGINEERING_CHECKS[i]||c.status!=='pass'||c.method!=='occt_brep_independent_readback'||!c.measured))fail();
+  if(!keys(recipe,['schema','checkerVersion','policy','baseline','targetOccurrenceId','candidateGlbSha256','placement','decorationGlbSha256','repair'])||!same(recipe.policy,ENGINEERING_POLICY)||recipe.schema!=='abelien.component-engineering-recipe.v1'||recipe.checkerVersion!==ENGINEERING_VERSION||!same(recipe.baseline,baseline)||recipe.candidateGlbSha256!==expected.candidateGlbSha256||recipe.targetOccurrenceId!==report.targetOccurrenceId)fail();
+  if(!same(report.asModeledOnlyOccurrenceIds,a.asModeledOnlyOccurrenceIds)||report.decorationGlbSha256!==sha256(files.get('decoration.glb'))||recipe.decorationGlbSha256!==report.decorationGlbSha256||!same(report.repair,recipe.repair))fail();
+  const p=a.proposal,placement=recipe.placement;
+  validateRepair(recipe.repair,expected.candidateGlbSha256,report.decorationGlbSha256,p.decoration.heightMm);
+  if(!keys(placement,['method','sourceUnits','scaleMmPerSourceUnit','translationMm','trimBottomMm','cutZMm','heightBeforeTrimMm'])||placement.method!=='declared_design_height'||placement.sourceUnits!=='unknown'||!finite(placement.scaleMmPerSourceUnit)||placement.scaleMmPerSourceUnit<=0||!Array.isArray(placement.translationMm)||placement.translationMm.length!==3||!placement.translationMm.every(finite)||!near(placement.trimBottomMm,p.decoration.heightMm*p.decoration.trimBottomFraction)||!near(placement.cutZMm,p.plate.thicknessMm+p.join.gapMm)||placement.heightBeforeTrimMm!==p.decoration.heightMm)fail();
+  const subject={sourceSha256:report.recipeSha256,modelStepSha256:report.modelStepSha256,modelGlbSha256:report.modelGlbSha256,assemblySha256:assembly.assemblySha256,occurrenceSetSha256:assembly.occurrenceSetSha256};
+  if(!same(report.subject,subject))fail();
+  validateMeasurements(report,expected);
+  validateAssemblyEvidence(assembly,report.recipeSha256,files.get('model.step'),files.get('model.glb'),files,()=>{
+    if(assembly.revision!==null||assembly.mode!=='occurrence_assembly')fail();
+  });
+  const unsigned={...assembly};delete unsigned.assemblySha256;
+  if(assembly.schema!=='abelien.structure-assembly.v2'||assembly.assemblySha256!==manifestHash(unsigned)||assembly.sourceSha256!==report.recipeSha256||assembly.units!=='mm'||
+    assembly.artifacts?.modelStepSha256!==report.modelStepSha256||assembly.artifacts?.modelGlbSha256!==report.modelGlbSha256||assembly.occurrenceCount!==expected.assembly.occurrenceCount)fail();
+  for(const old of expected.assembly.occurrences){const row=assembly.occurrences.find(r=>r.occurrenceId===old.occurrenceId);if(!row)fail();
+    if(row.occurrenceId!==report.targetOccurrenceId&&!same(row,old))fail();
+    if(row.occurrenceId===report.targetOccurrenceId&&!same(row,{...old,geometrySha256:row.geometrySha256,source:{kind:'generated_custom',sha256:report.recipeSha256},lineage:null}))fail();
+    if(!same(row.views,old.views)||row.interfaceSha256!==old.interfaceSha256||row.appearanceSha256!==old.appearanceSha256)fail();
+  }
+  for(const name of ['normal','internal','exploded'])if(assembly.views?.[name]?.imageSha256!==sha256(files.get(`${name}.png`))||assembly.views[name].modelGlbSha256!==report.modelGlbSha256)fail();
+  return {report,recipe,assembly};
+}

package/skills/abelien-structure/worker/engineering-policy.json

@@ -0,0 +1,16 @@
+{
+  "version": "planar-two-hole-fit.v1",
+  "maximumTriangles": 4000,
+  "linearToleranceMm": 1e-05,
+  "volumeToleranceMm3": 1e-05,
+  "maximumDimensionMm": 500,
+  "maximumOccurrences": 32,
+  "repair": {
+    "maximumIterations": 1,
+    "lambda": 0.25,
+    "maximumDisplacementMm": 0.25,
+    "maximumHeightFraction": 0.01,
+    "maximumVertexFraction": 0.05,
+    "maximumSignedVolumeRelativeChange": 0.001
+  }
+}

package/skills/abelien-structure/worker/engineering-repair.py

@@ -0,0 +1,147 @@
+"""One explicitly reported local position-only repair. Never changes input bytes or topology."""
+import hashlib
+import json
+import math
+import struct
+import numpy as np
+
+
+def require(condition, code):
+    if not condition:
+        raise ValueError('engineering_repair_' + code)
+
+
+def sha(body):
+    return hashlib.sha256(body).hexdigest()
+
+
+def layout(body, maximum_positions):
+    """Repair is deliberately limited to one static mesh primitive with float32 POSITION."""
+    size = struct.unpack_from('<I', body, 12)[0]
+    doc = json.loads(body[20:20+size])
+    nodes = [(i, n) for i, n in enumerate(doc['nodes']) if 'mesh' in n]
+    require(len(nodes) == 1, 'unsupported_mesh_instances')
+    node_index, node = nodes[0]
+    primitives = doc['meshes'][node['mesh']]['primitives']
+    require(len(primitives) == 1, 'unsupported_primitives')
+    primitive = primitives[0]
+    accessor = doc['accessors'][primitive['attributes']['POSITION']]
+    require(accessor['componentType'] == 5126 and accessor['type'] == 'VEC3', 'positions')
+    view = doc['bufferViews'][accessor['bufferView']]
+    offset = 28 + size + view.get('byteOffset', 0) + accessor.get('byteOffset', 0)
+    require(accessor['count'] <= maximum_positions, 'position_budget')
+    stride = view.get('byteStride', 12)
+    positions = np.array([struct.unpack_from('<fff', body, offset+i*stride) for i in range(accessor['count'])])
+    parents = {child: i for i, n in enumerate(doc['nodes']) for child in n.get('children', [])}
+    def matrix(index):
+        n = doc['nodes'][index]
+        if 'matrix' in n:
+            result = np.array(n['matrix']).reshape(4, 4, order='F')
+        else:
+            x, y, z, w = n.get('rotation', [0, 0, 0, 1])
+            result = np.eye(4)
+            result[:3, :3] = [[1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w)],
+                              [2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w)],
+                              [2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y)]]
+            result[:3, 3] = n.get('translation', [0, 0, 0])
+        return matrix(parents[index]) @ result if index in parents else result
+    transform = matrix(node_index)
+    require(np.allclose(transform[:3, :3].T @ transform[:3, :3], np.eye(3), atol=1e-8), 'nonrigid')
+    if 'indices' in primitive:
+        index = doc['accessors'][primitive['indices']]
+        iv = doc['bufferViews'][index['bufferView']]
+        kind = {5121: 'B', 5123: 'H', 5125: 'I'}[index['componentType']]
+        start = 28+size+iv.get('byteOffset', 0)+index.get('byteOffset', 0)
+        indexes = np.array([struct.unpack_from('<'+kind, body, start+i*iv.get('byteStride', struct.calcsize(kind)))[0]
+                            for i in range(index['count'])])
+    else:
+        indexes = np.arange(len(positions))
+    return positions, indexes.reshape(-1, 3), transform, offset, stride
+
+
+def physical(positions, transform, scale, translation):
+    world = positions @ transform[:3, :3].T + transform[:3, 3]
+    return world[:, [0, 2, 1]] * np.array([1, -1, 1]) * scale + translation
+
+
+def signed_volume(triangles):
+    return float(np.sum(np.einsum('ij,ij->i', triangles[:, 0], np.cross(triangles[:, 1], triangles[:, 2]))) / 6)
+
+
+def derive(original_triangles, source, self_evidence, placement, policy, build_solid, inspect_self):
+    vertices, indexes = np.unique(original_triangles.reshape(-1, 3), axis=0, return_inverse=True)
+    faces = indexes.reshape(-1, 3)
+    rule = policy['repair']
+    report = {'status': 'not_needed', 'method': 'none', 'originalGlbSha256': sha(source), 'derivedGlbSha256': sha(source),
+              'topologySha256': sha(source), 'topologyBinding': 'identical_bytes', 'iterations': 0,
+              'originalInterferenceCount': self_evidence['count'], 'remainingInterferenceCount': 0,
+              'uniqueVertexCount': len(vertices), 'changedVertexCount': 0, 'changedVertexFraction': 0,
+              'maximumDisplacementMm': 0, 'rmsDisplacementMm': 0, 'signedVolumeRelativeChange': 0,
+              'boundsMaximumChangeMm': 0, 'movedVertexIds': []}
+    if self_evidence['count'] == 0:
+        return original_triangles, source, report
+    neighbors = [set() for _ in vertices]
+    for face in faces:
+        for i in face:
+            neighbors[i].update(set(map(int, face)) - {int(i)})
+    seeds = set()
+    for point in self_evidence['points']:
+        distances = np.linalg.norm(vertices-point, axis=1)
+        index = int(distances.argmin())
+        require(distances[index] <= policy['linearToleranceMm'], 'unmapped_interference')
+        seeds.add(index)
+    selected = seeds | set().union(*(neighbors[i] for i in seeds))
+    require(0 < len(selected) / len(vertices) <= rule['maximumVertexFraction'], 'vertex_budget')
+    moved = vertices.copy()
+    maximum = min(rule['maximumDisplacementMm'], placement['heightBeforeTrimMm'] * rule['maximumHeightFraction'])
+    for i in selected:
+        delta = rule['lambda'] * (np.mean(vertices[list(neighbors[i])], axis=0)-vertices[i])
+        length = float(np.linalg.norm(delta))
+        moved[i] += delta * min(1, maximum/max(length, 1e-20))
+    raw, raw_faces, transform, offset, stride = layout(source, policy['maximumTriangles']*3)
+    scale = placement['scaleMmPerSourceUnit']
+    translation = np.array(placement['translationMm'])
+    before = physical(raw, transform, scale, translation)
+    require(raw_faces.shape == faces.shape and np.max(np.abs(before[raw_faces]-original_triangles)) < 1e-7, 'source_geometry')
+    # Write only original POSITION records; all indices, nodes, materials and other bytes stay exact.
+    derived = bytearray(source)
+    inverse = np.linalg.inv(transform)
+    touched = []
+    for i, point in enumerate(before):
+        distances = np.linalg.norm(vertices-point, axis=1)
+        index = int(distances.argmin())
+        if distances[index] > 1e-7 or index not in selected:
+            continue
+        normal = (moved[index]-translation)/scale
+        world = normal[[0, 2, 1]] * np.array([1, 1, -1])
+        local = inverse[:3, :3] @ world + inverse[:3, 3]
+        struct.pack_into('<fff', derived, offset+i*stride, *map(float, local))
+        touched.append(i)
+    next_raw, next_faces, next_transform, _, _ = layout(derived, policy['maximumTriangles']*3)
+    require(np.array_equal(raw_faces, next_faces) and np.array_equal(transform, next_transform), 'topology_changed')
+    after = physical(next_raw, transform, scale, translation)
+    delta = np.linalg.norm(after-before, axis=1)
+    require(float(delta.max()) <= maximum, 'displacement_budget')
+    # Equal logical vertices must still weld exactly; no components/triangles or vertex link can disappear.
+    next_vertices = np.unique(after[raw_faces].reshape(-1, 3), axis=0)
+    require(len(next_vertices) == len(vertices), 'vertex_count_changed')
+    zero_before, zero_after = bytearray(source), bytearray(derived)
+    for i in range(len(raw)):
+        zero_before[offset+i*stride:offset+i*stride+12] = b'\0'*12
+        zero_after[offset+i*stride:offset+i*stride+12] = b'\0'*12
+    require(zero_before == zero_after, 'non_position_bytes_changed')
+    triangles = after[raw_faces]
+    solid = build_solid(triangles)
+    remaining = inspect_self(solid)
+    require(remaining['count'] == 0, 'self_intersection_remaining')
+    old_volume, new_volume = signed_volume(original_triangles), signed_volume(triangles)
+    relative = abs(new_volume-old_volume)/abs(old_volume)
+    require(relative <= rule['maximumSignedVolumeRelativeChange'], 'volume_budget')
+    changed = sorted(i for i in selected if np.linalg.norm(moved[i]-vertices[i]) > 1e-12)
+    bounds = max(np.max(np.abs(before.min(axis=0)-after.min(axis=0))), np.max(np.abs(before.max(axis=0)-after.max(axis=0))))
+    report.update({'status': 'applied', 'method': 'bounded_local_laplacian', 'derivedGlbSha256': sha(derived),
+                   'topologySha256': sha(zero_before), 'topologyBinding': 'all_non_position_bytes', 'iterations': 1,
+                   'changedVertexCount': len(changed), 'changedVertexFraction': len(changed)/len(vertices),
+                   'maximumDisplacementMm': float(delta.max()), 'rmsDisplacementMm': float(np.sqrt(np.mean(delta**2))),
+                   'signedVolumeRelativeChange': relative, 'boundsMaximumChangeMm': float(bounds), 'movedVertexIds': changed})
+    return triangles, bytes(derived), report