abelien-harness 0.4.0 → 0.6.0

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

@@ -0,0 +1,451 @@
+/** Persistent queue; preflight/symbol failures allocate no job; views require artifact/hash/node-map validation. */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { containerName, removeContainer } from './sandbox.mjs';
+import {manifestCanonical} from './manifest-digest.mjs';
+import {ENGINEERING_ARTIFACT_TYPES,normalizeEngineeringFitRequest,validateAttachmentBaseline,validateEngineeringArtifacts} from './engineering-fit.mjs';
+import {glbJson,validateAssemblyEvidence} from './assembly-validation.mjs';
+import {validateInspectionGeometryPlan,validateInspectionGeometryTransport,validateInspectionGeometryEvidence} from './inspection-geometry.mjs';
+import {validateRepresentation} from './representation.mjs';
+const hash = value => createHash('sha256').update(value).digest('hex');
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const HEX = /^[a-f0-9]{64}$/;
+const STABLE = /^[a-z0-9][a-z0-9._:-]{0,127}$/;
+const TARGET_ID = /^[A-Za-z0-9][A-Za-z0-9:_.-]{0,127}$/;
+const NODE_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const VIEWS = ['normal', 'internal', 'exploded'];
+const DEFERRED = ['voltage', 'peak_current', 'port_occupancy', 'logic_level', 'concurrent_resources', 'actuator_load'];
+const REVISION_CHANGES=['geometry','transform','interfaces','appearance_mapping'];
+const LIBRARY_DIAGNOSTIC_CODES=new Set(['library_unknown','library_argument_unknown','library_argument_positional','build123d_unknown']);
+/** One printable abelien_cad signature, e.g. extrude_profile(profile, *, height); generated from the trusted library AST. */
+const LIBRARY_SIGNATURE=/^[a-z_][a-z0-9_]{0,63}\([\x20-\x7e]{0,230}\)$/;
+const libraryDiagnostic=value=>{
+  if(!LIBRARY_DIAGNOSTIC_CODES.has(value?.code)||!Array.isArray(value.names)||!value.names.length||value.names.length>5)return undefined;
+  const pattern=value.code==='library_argument_unknown'?/^[A-Za-z_][A-Za-z0-9_]{0,63}\.[A-Za-z_][A-Za-z0-9_]{0,63}$/:/^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+  if(!value.names.every(name=>typeof name==='string'&&pattern.test(name)))return undefined;
+  if(!value.code.startsWith('library_argument_'))return value.signatures===undefined?{code:value.code,names:value.names}:undefined;
+  // Argument errors must name the exact signature of every affected function, in name order.
+  const functions=[...new Set(value.names.map(name=>name.split('.')[0]))].sort();
+  return Array.isArray(value.signatures)&&value.signatures.length===functions.length
+    &&value.signatures.every((signature,index)=>typeof signature==='string'&&LIBRARY_SIGNATURE.test(signature)&&signature.startsWith(`${functions[index]}(`))
+    ?{code:value.code,names:value.names,signatures:value.signatures}:undefined;
+};
+export const ARTIFACT_TYPES = { 'model.step': 'model/step', 'model.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',
+  'geometry.json': 'application/json', 'assembly.json': 'application/json', 'model.py': 'text/plain' };
+const error = code => Object.assign(new Error(code), { code });
+const canonical = value => Array.isArray(value) ? `[${value.map(canonical).join(',')}]`
+  : value && typeof value === 'object' ? `{${Object.entries(value).sort(([a],[b]) => a.localeCompare(b)).map(([key,item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(',')}}`
+    : JSON.stringify(value);
+const finiteVector = value => Array.isArray(value) && value.length === 3 && value.every(item => typeof item === 'number' && Number.isFinite(item));
+/** Repair must change an authorized physical target, not only a source or display/report version. */
+export function revisionHasPhysicalChange(previous,current,summary){
+  const targets=new Set(summary.targetOccurrenceIds);
+  const identities={geometry:item=>item.geometrySha256,transform:item=>manifestCanonical(item.views.normal),appearance_mapping:item=>manifestCanonical(item.material??null)};
+  return summary.replacementMappings.some(mapping=>mapping.previousOccurrenceIds.some(id=>targets.has(id))&&
+    Object.entries(identities).some(([change,identity])=>summary.allowedChanges.includes(change)&&
+      canonical(mapping.previousOccurrenceIds.map(id=>identity(previous.get(id))).sort())!==canonical(mapping.nextOccurrenceIds.map(id=>identity(current.get(id))).sort())));
+}
+const nodeList=(value,{empty=false}={})=>Array.isArray(value)&&(empty||value.length>0)&&value.length<=128&&new Set(value).size===value.length&&value.every(item=>typeof item==='string'&&NODE_ID.test(item));
+const targetList=(value,{empty=false,maximum=512}={})=>Array.isArray(value)&&(empty||value.length>0)&&value.length<=maximum&&new Set(value).size===value.length&&value.every(item=>typeof item==='string'&&TARGET_ID.test(item));
+function normalizeRevisionInput(value){
+  if(value===undefined||value===null)return null;
+  const keys=['priorJobId','priorSubject','targetOccurrenceIds','allowedChanges','preserveOccurrenceIds','preserveAppearanceTargetIds','appearanceTargetBindings','replacementMappings','mountAlignments'];
+  if(!exactKeys(value,keys)||!UUID.test(value.priorJobId??'')||!exactKeys(value.priorSubject,['sourceSha256','assemblySha256','occurrenceSetSha256'])||
+    Object.values(value.priorSubject).some(item=>typeof item!=='string'||!HEX.test(item))||!nodeList(value.targetOccurrenceIds)||!nodeList(value.preserveOccurrenceIds,{empty:true})||
+    value.targetOccurrenceIds.some(id=>value.preserveOccurrenceIds.includes(id))||
+    !Array.isArray(value.allowedChanges)||!value.allowedChanges.length||value.allowedChanges.length>REVISION_CHANGES.length||new Set(value.allowedChanges).size!==value.allowedChanges.length||value.allowedChanges.some(item=>!REVISION_CHANGES.includes(item))||
+    !targetList(value.preserveAppearanceTargetIds,{empty:true})||!Array.isArray(value.appearanceTargetBindings)||value.appearanceTargetBindings.length!==value.preserveAppearanceTargetIds.length||!Array.isArray(value.replacementMappings)||!value.replacementMappings.length||value.replacementMappings.length>128||
+    !Array.isArray(value.mountAlignments)||value.mountAlignments.length>128)throw error('invalid_input');
+  const appearanceTargetBindings=value.appearanceTargetBindings.map((item,index)=>{
+    if(!exactKeys(item,['targetId','occurrenceId'])||item.targetId!==value.preserveAppearanceTargetIds[index]||!TARGET_ID.test(item.targetId??'')||!NODE_ID.test(item.occurrenceId??''))throw error('invalid_input');
+    return {targetId:item.targetId,occurrenceId:item.occurrenceId};
+  });
+  if(new Set(appearanceTargetBindings.map(item=>item.targetId)).size!==appearanceTargetBindings.length)throw error('invalid_input');
+  const replacementMappings=value.replacementMappings.map(item=>{
+    if(!exactKeys(item,['kind','previousOccurrenceIds','nextOccurrenceIds'])||!['preserved','replaced','split','merged'].includes(item.kind)||!nodeList(item.previousOccurrenceIds)||!nodeList(item.nextOccurrenceIds))throw error('invalid_input');
+    if(['preserved','replaced'].includes(item.kind)&&(item.previousOccurrenceIds.length!==1||item.nextOccurrenceIds.length!==1)||item.kind==='split'&&(item.previousOccurrenceIds.length!==1||item.nextOccurrenceIds.length<2)||item.kind==='merged'&&(item.previousOccurrenceIds.length<2||item.nextOccurrenceIds.length!==1))throw error('invalid_input');
+    return {kind:item.kind,previousOccurrenceIds:[...item.previousOccurrenceIds],nextOccurrenceIds:[...item.nextOccurrenceIds]};
+  });
+  const mountAlignments=value.mountAlignments.map(item=>{
+    const alignmentKeys=['previousOccurrenceId','previousFrameId','nextOccurrenceId','nextFrameId','compatibilityKey'];
+    if(!exactKeys(item,alignmentKeys)||!NODE_ID.test(item.previousOccurrenceId??'')||!NODE_ID.test(item.previousFrameId??'')||!NODE_ID.test(item.nextOccurrenceId??'')||!NODE_ID.test(item.nextFrameId??'')||!STABLE.test(item.compatibilityKey??''))throw error('invalid_input');
+    return Object.fromEntries(alignmentKeys.map(key=>[key,item[key]]));
+  });
+  if(new Set(mountAlignments.map(item=>item.previousOccurrenceId)).size!==mountAlignments.length||new Set(mountAlignments.map(item=>item.nextOccurrenceId)).size!==mountAlignments.length)throw error('invalid_input');
+  const unsigned={schema:'abelien.structure-revision.v1',prior:{jobId:value.priorJobId,...value.priorSubject},targetOccurrenceIds:[...value.targetOccurrenceIds],allowedChanges:[...value.allowedChanges],
+    preserveOccurrenceIds:[...value.preserveOccurrenceIds],preserveAppearanceTargetIds:[...value.preserveAppearanceTargetIds],appearanceTargetBindings,replacementMappings,mountAlignments};
+  return {...unsigned,requestSha256:hash(manifestCanonical(unsigned))};
+}
+function revisionErrors(previous,next,previousFrameId,nextFrameId){
+  const matrix=occurrence=>{
+    const frame=occurrence.mountFrames.find(item=>item.frameId===(occurrence===previous?previousFrameId:nextFrameId));if(!frame)throw error('invalid_artifact');
+    const rotation=degrees=>{const [x,y,z]=degrees.map(value=>value*Math.PI/180),cx=Math.cos(x),sx=Math.sin(x),cy=Math.cos(y),sy=Math.sin(y),cz=Math.cos(z),sz=Math.sin(z);return [[cy*cz,-cy*sz,sy],[sx*sy*cz+cx*sz,-sx*sy*sz+cx*cz,-sx*cy],[-cx*sy*cz+sx*sz,cx*sy*sz+sx*cz,cx*cy]];};
+    const multiply=(left,right)=>left.map((row,i)=>right[0].map((_,j)=>row.reduce((sum,item,k)=>sum+item*right[k][j],0)));
+    const normal=occurrence.views.normal,rn=rotation(normal.rotationDeg),rf=rotation(frame.rotationDeg),position=normal.translationMm.map((value,index)=>value+rn[index].reduce((sum,item,axis)=>sum+item*frame.translationMm[axis],0));
+    return {rotation:multiply(rn,rf),position};
+  };
+  const before=matrix(previous),after=matrix(next),translationErrorMm=Math.sqrt(before.position.reduce((sum,item,index)=>sum+(item-after.position[index])**2,0));
+  let trace=0;for(let axis=0;axis<3;axis++)for(let row=0;row<3;row++)trace+=before.rotation[row][axis]*after.rotation[row][axis];
+  const rotationErrorDeg=Math.acos(Math.max(-1,Math.min(1,(trace-1)/2)))*180/Math.PI;
+  return {translationErrorMm,rotationErrorDeg};
+}
+function validateRevisionManifest(value,sourceSha256,expected){
+  if(!expected){if(value.revision!==null||value.occurrences.some(item=>item.lineage!==null||item.source.sha256!==sourceSha256))throw error('invalid_artifact');return;}
+  const {summary,priorAssembly}=expected;if(canonical(value.revision)!==canonical(summary))throw error('invalid_artifact');
+  const previous=new Map(priorAssembly.occurrences.map(item=>[item.occurrenceId,item])),current=new Map(value.occurrences.map(item=>[item.occurrenceId,item])),alignedTargets=new Set(summary.mountAlignments.map(item=>item.nextOccurrenceId));
+  const priorSeen=new Set(),nextSeen=new Set(),changes={geometry:'geometrySha256',transform:'transformSha256',interfaces:'interfaceSha256',appearance_mapping:'appearanceSha256'};
+  for(const mapping of summary.replacementMappings){
+    for(const id of mapping.previousOccurrenceIds){if(!previous.has(id)||priorSeen.has(id))throw error('invalid_artifact');priorSeen.add(id);}
+    for(const id of mapping.nextOccurrenceIds){if(!current.has(id)||nextSeen.has(id))throw error('invalid_artifact');nextSeen.add(id);const lineage=current.get(id).lineage;if(canonical(lineage)!==canonical({kind:mapping.kind,priorAssemblySha256:priorAssembly.assemblySha256,previousOccurrenceIds:mapping.previousOccurrenceIds}))throw error('invalid_artifact');}
+    for(const [change,field] of Object.entries(changes))if(canonical(mapping.previousOccurrenceIds.map(id=>previous.get(id)[field]).sort())!==canonical(mapping.nextOccurrenceIds.map(id=>current.get(id)[field]).sort())&&!(change==='transform'&&mapping.nextOccurrenceIds.every(id=>alignedTargets.has(id)))&&!summary.allowedChanges.includes(change))throw error('invalid_artifact');
+  }
+  if(priorSeen.size!==previous.size||nextSeen.size!==current.size)throw error('invalid_artifact');
+  for(const id of summary.preserveOccurrenceIds){const before=previous.get(id),after=current.get(id),mapping=summary.replacementMappings.find(item=>canonical(item.previousOccurrenceIds)===canonical([id]));if(!before||!after||mapping?.kind!=='preserved'||canonical(mapping.nextOccurrenceIds)!==canonical([id])||['geometrySha256','transformSha256','interfaceSha256','appearanceSha256'].some(field=>before[field]!==after[field])||after.source.sha256!==before.source.sha256)throw error('invalid_artifact');}
+  for(const binding of summary.appearanceTargetBindings){const before=previous.get(binding.occurrenceId),mapping=summary.replacementMappings.find(item=>item.previousOccurrenceIds.includes(binding.occurrenceId));if(!before||!mapping||mapping.previousOccurrenceIds.length!==1||mapping.nextOccurrenceIds.length!==1||current.get(mapping.nextOccurrenceIds[0])?.appearanceSha256!==before.appearanceSha256)throw error('invalid_artifact');}
+  for(const alignment of summary.mountAlignments){const before=previous.get(alignment.previousOccurrenceId),after=current.get(alignment.nextOccurrenceId);if(!before||!after||!before.interfaces.some(item=>item.frameId===alignment.previousFrameId&&item.compatibilityKey===alignment.compatibilityKey)||!after.interfaces.some(item=>item.frameId===alignment.nextFrameId&&item.compatibilityKey===alignment.compatibilityKey))throw error('invalid_artifact');const errors=revisionErrors(before,after,alignment.previousFrameId,alignment.nextFrameId);if(errors.translationErrorMm>1e-6||errors.rotationErrorDeg>1e-6)throw error('invalid_artifact');}
+}
+function validateAssembly(value, sourceSha256, step, glb, files, expectedRevision) {
+  return validateAssemblyEvidence(value,sourceSha256,step,glb,files,()=>validateRevisionManifest(value,sourceSha256,expectedRevision));
+}
+const GEOMETRY_CHECKS=['collision','containment','opening_alignment','motion_envelope'];
+const exactKeys=(value,keys)=>value&&typeof value==='object'&&!Array.isArray(value)&&canonical(Object.keys(value).sort())===canonical([...keys].sort());
+const threshold=value=>typeof value==='number'&&Number.isFinite(value)&&value>=0;
+function expectedInspection(plan,assembly){
+  const ids=new Set(assembly.occurrences.map(item=>item.occurrenceId));
+  const extended=plan?.schema==='abelien.structure-inspection-plan.v2';
+  if(!exactKeys(plan,['schema','collision','containment','openings','motionEnvelopes',...(extended?['inspectionGeometry']:[])])||(!extended&&plan.schema!=='abelien.structure-inspection-plan.v1'))throw error('invalid_artifact');
+  const regions=validateInspectionGeometryPlan(plan.inspectionGeometry,assembly);
+  if(extended&&!regions.size)throw error('invalid_artifact');
+  const listed=(value,minimum=1)=>Array.isArray(value)&&value.length>=minimum&&value.length<=128&&new Set(value).size===value.length&&value.every(id=>ids.has(id));
+  const omitted=value=>exactKeys(value,['kind','reason'])&&value.kind==='not_applicable'&&typeof value.reason==='string'&&value.reason.length>0&&value.reason.length<=300;
+  const result={};
+  const prepare=(name,spec,signatures)=>{
+    if(spec===null){result[name]={kind:'unknown',reason:'inspection_not_declared',signatures:[]};return;}
+    if(omitted(spec)){result[name]={kind:'not_applicable',reason:spec.reason,signatures:[]};return;}
+    result[name]={kind:'rules',reason:null,signatures:signatures(spec)};
+    if(result[name].signatures.length>256)throw error('invalid_artifact');
+  };
+  prepare('collision',plan.collision,spec=>{
+    if(!exactKeys(spec,['kind','occurrenceIds','allowedPairs','maximumOverlapMm3'])||spec.kind!=='rules'||!listed(spec.occurrenceIds,2)||!threshold(spec.maximumOverlapMm3)||!Array.isArray(spec.allowedPairs))throw error('invalid_artifact');
+    const allowed=new Set();
+    for(const pair of spec.allowedPairs){if(!Array.isArray(pair)||pair.length!==2||pair[0]>=pair[1]||!spec.occurrenceIds.includes(pair[0])||!spec.occurrenceIds.includes(pair[1]))throw error('invalid_artifact');const key=pair.join('\0');if(allowed.has(key))throw error('invalid_artifact');allowed.add(key);}
+    const signatures=[];for(let left=0;left<spec.occurrenceIds.length;left++)for(let right=left+1;right<spec.occurrenceIds.length;right++){
+      const pair=[spec.occurrenceIds[left],spec.occurrenceIds[right]].sort();if(!allowed.has(pair.join('\0')))signatures.push({subjectIds:pair,metric:'overlap_volume_mm3',operator:'<=',threshold:spec.maximumOverlapMm3});
+    }return signatures;
+  });
+  prepare('containment',plan.containment,spec=>{
+    if(!exactKeys(spec,['kind','rules'])||spec.kind!=='rules'||!Array.isArray(spec.rules)||!spec.rules.length||spec.rules.length>128)throw error('invalid_artifact');
+    return spec.rules.flatMap(rule=>{if(!exactKeys(rule,['container','targets','maximumOutsideMm3'])||(!ids.has(rule.container)&&regions.get(rule.container)?.kind!=='cavity')||!listed(rule.targets)||rule.targets.includes(rule.container)||!threshold(rule.maximumOutsideMm3))throw error('invalid_artifact');return rule.targets.map(target=>({subjectIds:[rule.container,target],metric:'outside_volume_mm3',operator:'<=',threshold:rule.maximumOutsideMm3}));});
+  });
+  prepare('opening_alignment',plan.openings,spec=>{
+    if(!exactKeys(spec,['kind','rules'])||spec.kind!=='rules'||!Array.isArray(spec.rules)||!spec.rules.length||spec.rules.length>128)throw error('invalid_artifact');
+    return spec.rules.flatMap(rule=>{if(!exactKeys(rule,['opening','target','maximumDistanceMm','minimumOverlapMm3'])||(!ids.has(rule.opening)&&regions.get(rule.opening)?.kind!=='opening')||!ids.has(rule.target)||rule.opening===rule.target||!threshold(rule.maximumDistanceMm)||!threshold(rule.minimumOverlapMm3)||(regions.has(rule.opening)&&rule.minimumOverlapMm3<=0))throw error('invalid_artifact');return [
+      {subjectIds:[rule.opening,rule.target],metric:'distance_mm',operator:'<=',threshold:rule.maximumDistanceMm},
+      {subjectIds:[rule.opening,rule.target],metric:'overlap_volume_mm3',operator:'>=',threshold:rule.minimumOverlapMm3},
+    ];});
+  });
+  prepare('motion_envelope',plan.motionEnvelopes,spec=>{
+    if(!exactKeys(spec,['kind','rules'])||spec.kind!=='rules'||!Array.isArray(spec.rules)||!spec.rules.length||spec.rules.length>128)throw error('invalid_artifact');
+    return spec.rules.flatMap(rule=>{if(!exactKeys(rule,['envelope','obstacles','maximumOverlapMm3'])||!ids.has(rule.envelope)||!listed(rule.obstacles)||rule.obstacles.includes(rule.envelope)||!threshold(rule.maximumOverlapMm3))throw error('invalid_artifact');return rule.obstacles.map(obstacle=>({subjectIds:[rule.envelope,obstacle],metric:'overlap_volume_mm3',operator:'<=',threshold:rule.maximumOverlapMm3}));});
+  });
+  return result;
+}
+function validateRevisionChecks(value,assembly,expected){
+  if(!exactKeys(value,['delta','preservation','mount']))throw error('invalid_artifact');
+  if(!expected){for(const name of ['delta','preservation','mount'])if(canonical(value[name])!==canonical({status:'not_applicable',method:'declared_not_applicable',reason:'initial_build',findings:[]}))throw error('invalid_artifact');return;}
+  const previous=new Map(expected.priorAssembly.occurrences.map(item=>[item.occurrenceId,item])),current=new Map(assembly.occurrences.map(item=>[item.occurrenceId,item]));
+  if(!revisionHasPhysicalChange(previous,current,expected.summary))throw error('invalid_artifact');
+  const fields={geometry:'geometrySha256',transform:'transformSha256',interfaces:'interfaceSha256',appearance_mapping:'appearanceSha256'},alignedTargets=new Set(expected.summary.mountAlignments.map(item=>item.nextOccurrenceId));
+  const delta=expected.summary.replacementMappings.map(mapping=>({kind:mapping.kind,previousOccurrenceIds:mapping.previousOccurrenceIds,nextOccurrenceIds:mapping.nextOccurrenceIds,changes:Object.entries(fields).filter(([name,field])=>canonical(mapping.previousOccurrenceIds.map(id=>previous.get(id)[field]).sort())!==canonical(mapping.nextOccurrenceIds.map(id=>current.get(id)[field]).sort())&&!(name==='transform'&&mapping.nextOccurrenceIds.every(id=>alignedTargets.has(id)))).map(([name])=>name)}));
+  const preservation=expected.summary.preserveOccurrenceIds.map(id=>({previousOccurrenceId:id,nextOccurrenceId:id,geometryPreserved:true,transformPreserved:true,interfacesPreserved:true,appearancePreserved:true}));
+  const mount=expected.summary.mountAlignments.map(alignment=>{const before=previous.get(alignment.previousOccurrenceId),after=current.get(alignment.nextOccurrenceId),errors=revisionErrors(before,after,alignment.previousFrameId,alignment.nextFrameId);return {...alignment,...errors,compatible:true,aligned:errors.translationErrorMm<=1e-6&&errors.rotationErrorDeg<=1e-6};});
+  const expectedChecks={delta:{status:'pass',method:'manifest_digest',reason:null,findings:delta},preservation:{status:'pass',method:'manifest_digest',reason:null,findings:preservation},mount:{status:'pass',method:'frame_alignment',reason:null,findings:mount}};
+  const near=(left,right)=>typeof left==='number'&&typeof right==='number'?Math.abs(left-right)<=1e-8:canonical(left)===canonical(right);
+  for(const name of ['delta','preservation'])if(canonical(value[name])!==canonical(expectedChecks[name]))throw error('invalid_artifact');
+  const actualMount=value.mount,expectedMount=expectedChecks.mount;
+  if(!exactKeys(actualMount,['status','method','reason','findings'])||actualMount.status!=='pass'||actualMount.method!=='frame_alignment'||actualMount.reason!==null||!Array.isArray(actualMount.findings)||actualMount.findings.length!==expectedMount.findings.length)throw error('invalid_artifact');
+  actualMount.findings.forEach((finding,index)=>{const expectedFinding=expectedMount.findings[index];if(!exactKeys(finding,Object.keys(expectedFinding))||Object.keys(expectedFinding).some(key=>!near(finding[key],expectedFinding[key])))throw error('invalid_artifact');});
+}
+function validateInspection(value, assembly, plan, expectedRevision, representation) {
+  if(!value||typeof value!=='object'||value.schema!=='abelien.structure-inspection.v2'||value.units!=='mm'||typeof value.build123d!=='string'||!value.build123d||value.visual_review!=='review_required'||
+    !value.assembly||value.assembly.mode!==assembly.mode||value.assembly.sha256!==assembly.assemblySha256||value.assembly.occurrence_count!==assembly.occurrenceCount||
+    value.assembly.node_mapping!==(assembly.mode==='occurrence_assembly')||value.assembly.inspection_plan_sha256!==assembly.inspectionPlanSha256||!value.checks||
+    value.checks.step_readback!==true||value.checks.solid_validity!==true||!Number.isSafeInteger(value.checks.solid_count)||value.checks.solid_count<1||
+    !finiteVector(value.checks.dimensions_mm)||value.checks.dimensions_mm.some(item=>item<=0)||typeof value.checks.volume_mm3!=='number'||!Number.isFinite(value.checks.volume_mm3)||value.checks.volume_mm3<=0||
+    !value.checks.geometry||!value.checks.revision||!Array.isArray(value.not_checked)||value.not_checked.length>32||new Set(value.not_checked).size!==value.not_checked.length||
+    value.not_checked.some(item=>typeof item!=='string'||!/^[a-z][a-z0-9_]{0,63}$/.test(item))||DEFERRED.some(item=>!value.not_checked.includes(item)))throw error('invalid_artifact');
+  const ids=new Set(assembly.occurrences.map(occurrence=>occurrence.occurrenceId));
+  if(hash(manifestCanonical(plan))!==assembly.inspectionPlanSha256)throw error('invalid_artifact');
+  const expected=expectedInspection(plan,assembly);
+  const regions=validateInspectionGeometryPlan(plan.inspectionGeometry,assembly);
+  validateInspectionGeometryEvidence(value.inspectionGeometry,plan.inspectionGeometry,assembly);
+  for(const name of GEOMETRY_CHECKS){
+    const check=value.checks.geometry[name],planned=expected[name];
+    if(!check||!['pass','conflict','unknown','not_applicable'].includes(check.status)||!['occt_brep','unavailable','declared_not_applicable'].includes(check.method)||check.planSha256!==assembly.inspectionPlanSha256||
+      !(check.reason===null||typeof check.reason==='string'&&check.reason.length>0&&check.reason.length<=300)||!Array.isArray(check.findings)||check.findings.length>256)throw error('invalid_artifact');
+    for(const finding of check.findings){
+      if(!finding||!Array.isArray(finding.subjectIds)||finding.subjectIds.length!==2||finding.subjectIds[0]===finding.subjectIds[1]||!ids.has(finding.subjectIds[1])||
+        (!ids.has(finding.subjectIds[0])&&!(name==='containment'&&regions.get(finding.subjectIds[0])?.kind==='cavity')&&!(name==='opening_alignment'&&regions.get(finding.subjectIds[0])?.kind==='opening'))||
+        !['overlap_volume_mm3','outside_volume_mm3','distance_mm'].includes(finding.metric)||typeof finding.measured!=='number'||!Number.isFinite(finding.measured)||finding.measured<0||
+        !['<=','>='].includes(finding.operator)||typeof finding.threshold!=='number'||!Number.isFinite(finding.threshold)||finding.threshold<0||typeof finding.passed!=='boolean'||
+        finding.passed!==(finding.operator==='<='?finding.measured<=finding.threshold:finding.measured>=finding.threshold))throw error('invalid_artifact');
+    }
+    if(check.status==='unknown'&&(check.method!=='unavailable'||!check.reason||check.findings.length||!value.not_checked.includes(name)))throw error('invalid_artifact');
+    if(check.status==='not_applicable'&&(check.method!=='declared_not_applicable'||!check.reason||check.findings.length||value.not_checked.includes(name)))throw error('invalid_artifact');
+    if(['pass','conflict'].includes(check.status)&&(check.method!=='occt_brep'||check.reason!==null||value.not_checked.includes(name)||check.status!==(check.findings.every(item=>item.passed)?'pass':'conflict')))throw error('invalid_artifact');
+    if(planned.kind==='unknown'&&(check.status!=='unknown'||check.reason!==planned.reason)||planned.kind==='not_applicable'&&(check.status!=='not_applicable'||check.reason!==planned.reason)||
+      planned.kind==='rules'&&check.status==='not_applicable'||planned.kind==='rules'&&check.status==='unknown'&&check.reason!=='brep_operation_failed'||
+      planned.kind==='rules'&&['pass','conflict'].includes(check.status)&&canonical(check.findings.map(({subjectIds,metric,operator,threshold})=>({subjectIds,metric,operator,threshold})))!==canonical(planned.signatures))throw error('invalid_artifact');
+  }
+  validateRevisionChecks(value.checks.revision,assembly,expectedRevision);
+  const reported=validateRepresentation(value.representation,assembly,value.not_checked);
+  if(canonical(reported)!==canonical(representation))throw error('invalid_artifact');
+  return value;
+}
+function requireScope(scope) { if (typeof scope !== 'string' || !HEX.test(scope)) throw error('invalid_input'); }
+function atomic(file, body) {
+  const temp = `${file}.${randomUUID()}.tmp`;
+  fs.writeFileSync(temp, JSON.stringify(body), { mode: 0o600 });
+  fs.renameSync(temp, file);
+}
+const DIAGNOSTIC_STAGES = new Set(['source_exec', 'assembly_contract', 'step_export', 'geometry_validation']);
+/** Re-whitelist the sandbox's failure reason; lines count from the submitted source (or revision patch). */
+function failureDiagnostic(value, offset = 0) {
+  if (!value || typeof value !== 'object' || !DIAGNOSTIC_STAGES.has(value.stage)) return null;
+  const exceptionType = typeof value.exceptionType === 'string' && /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(value.exceptionType) ? value.exceptionType : 'Error';
+  const message = typeof value.message === 'string' ? value.message.replace(/\p{C}/gu, ' ').slice(0, 200) : '';
+  const line = Number.isSafeInteger(value.line) && value.line > offset && value.line - offset <= 32768 ? value.line - offset : null;
+  return { stage: value.stage, exceptionType, message, line };
+}
+function publicJob(job) {
+  const { id, title, pass, basis, status, createdAt, updatedAt, error: failure, diagnostic, artifacts, assembly } = job;
+  return { id, title, pass, basis, status, createdAt, updatedAt, ...(failure ? { error: failure } : {}),
+    ...(diagnostic ? { diagnostic } : {}), artifacts,
+    ...(assembly ? { assembly } : {}),
+    ...(job.attachment?{attachment:job.attachment}:{}),
+    ...(job.operation?{operation:job.operation}:{}),
+    ...(job.engineeringFit?{engineeringFit:job.engineeringFit}:{}),
+    visualReview: 'review_required', adopted: false };
+}
+export function createJobQueue({ root, sandbox, sourceApi, timeoutMs = 180000, preflightTimeoutMs = 10000, maxJobs = 1000, cleanup = removeContainer, build123dNames = null }) {
+  if (!path.isAbsolute(root) || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || !Number.isSafeInteger(preflightTimeoutMs) || preflightTimeoutMs < 1 || preflightTimeoutMs > 10000) throw error('configuration_invalid');
+  if(build123dNames!==null&&(!Array.isArray(build123dNames)||!build123dNames.length||build123dNames.length>4096||build123dNames.some(name=>typeof name!=='string'||!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(name))))throw error('configuration_invalid');
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  const jobs = new Map(), keyIndex=new Map(), controllers = new Map();
+  let pumping = false, closed = false, preflightController;
+  const folder = id => path.join(root, id);
+  const save = job => { job.updatedAt = new Date().toISOString(); atomic(path.join(folder(job.id), 'job.json'), job); };
+  const get = (scope, id) => {
+    requireScope(scope);
+    if (typeof id !== 'string' || !UUID.test(id)) throw error('invalid_input');
+    const job = jobs.get(id);
+    if (!job || job.scope !== scope) throw error('not_found');
+    return job;
+  };
+  const upstreamIndex=(scope,key)=>{requireScope(scope);if(typeof key!=='string'||!HEX.test(key))throw error('invalid_input');return `${scope}:${key}`;};
+  const readJobArtifact=(job,name)=>{
+    const asset=job.artifacts.find(item=>item.name===name);if(job.status!=='succeeded'||!asset)throw error('invalid_input');
+    const file=path.join(folder(job.id),name),stat=fs.lstatSync(file);if(!stat.isFile()||stat.isSymbolicLink()||stat.size!==asset.bytes)throw error('artifact_changed');
+    const body=fs.readFileSync(file);if(hash(body)!==asset.sha256)throw error('artifact_changed');return body;
+  };
+  const revisionExpected=(scope,summary)=>{
+    if(!summary)return null;
+    const prior=get(scope,summary.prior.jobId);if(prior.status!=='succeeded'||prior.assembly?.schema!=='abelien.structure-assembly.v2'||prior.assembly.mode!=='occurrence_assembly')throw error('invalid_input');
+    const source=readJobArtifact(prior,'model.py'),assembly=JSON.parse(readJobArtifact(prior,'assembly.json').toString('utf8'));
+    if(hash(source)!==summary.prior.sourceSha256||assembly.sourceSha256!==summary.prior.sourceSha256||assembly.assemblySha256!==summary.prior.assemblySha256||assembly.occurrenceSetSha256!==summary.prior.occurrenceSetSha256||canonical(assembly)!==canonical(prior.assembly))throw error('conflict');
+    const ids=new Set(assembly.occurrences.map(item=>item.occurrenceId)),partition=[...summary.targetOccurrenceIds,...summary.preserveOccurrenceIds];
+    if(new Set(partition).size!==ids.size||partition.some(id=>!ids.has(id)))throw error('invalid_input');
+    return {summary,priorAssembly:assembly,priorSource:source.toString('utf8')};
+  };
+  const effectiveSource=(patch,expected)=>expected?`${expected.priorSource}\n# abelien-structure revision boundary\n${patch}`:patch;
+  const fitExpected=(scope,fit)=>{
+    const prior=get(scope,fit.priorJobId);
+    if(prior.status!=='succeeded'||prior.operation||!prior.attachment)throw error('invalid_input');
+    const assembly=JSON.parse(readJobArtifact(prior,'assembly.json')),step=readJobArtifact(prior,'model.step'),source=readJobArtifact(prior,'model.py');
+    if(hash(source)!==fit.priorSubject.sourceSha256||['sourceSha256','assemblySha256','occurrenceSetSha256'].some(k=>assembly[k]!==fit.priorSubject[k])||canonical(assembly)!==canonical(prior.assembly))throw error('conflict');
+    const attachment=validateAttachmentBaseline(JSON.parse(readJobArtifact(prior,'attachment.json')),assembly,step);
+    if(attachment.attachmentSha256!==fit.attachmentSha256||canonical(attachment)!==canonical(prior.attachment))throw error('conflict');
+    return {assembly,step,attachment,candidateGlbSha256:fit.candidateGlb.sha256};
+  };
+  async function runEngineering(job,signal){
+    const expected=fitExpected(job.scope,job.fit);
+    const {triangles}=normalizeEngineeringFitRequest(Object.fromEntries(['operation','key','basis','title','pass','fit'].map(k=>[k,job[k]])));
+    const payload={baselineStep:expected.step.toString('base64'),baselineAssembly:expected.assembly,attachment:expected.attachment,
+      candidateGlbSha256:expected.candidateGlbSha256,candidateGlb:job.fit.candidateGlb.base64,triangles};
+    const built=await sandbox(job.id,'build',{mode:'component_fit_build',...payload},signal);
+    if(built?.diagnostic)throw Object.assign(error('source_failed'),{diagnostic:failureDiagnostic(built.diagnostic)});
+    if(signal.aborted)throw error('interrupted');
+    if(typeof built.step!=='string'||!built.recipe)throw error('invalid_artifact');
+    job.status='validating';save(job);
+    const inspected=await sandbox(job.id,'inspect',{mode:'component_fit_inspect',...payload,step:built.step,recipe:built.recipe,decorationGlb:built.decorationGlb},signal);
+    if(inspected?.diagnostic)throw Object.assign(error('source_failed'),{diagnostic:failureDiagnostic(inspected.diagnostic)});
+    if(signal.aborted)throw error('interrupted');
+    const decoded=new Map(),outputs=[];
+    if(!inspected?.artifacts||Object.keys(inspected.artifacts).sort().join(',')!==Object.keys(ENGINEERING_ARTIFACT_TYPES).sort().join(','))throw error('invalid_artifact');
+    for(const [name,mediaType] of Object.entries(ENGINEERING_ARTIFACT_TYPES)){
+      const encoded=inspected.artifacts[name];if(typeof encoded!=='string')throw error('invalid_artifact');
+      const body=Buffer.from(encoded,'base64'),max=name.endsWith('.png')?4*1024*1024:name.endsWith('.json')?128*1024:24*1024*1024;
+      if(!body.length||body.length>max||body.toString('base64')!==encoded)throw error('invalid_artifact');
+      if(name.endsWith('.png')&&!body.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])))throw error('invalid_artifact');
+      if(name.endsWith('.step')&&!body.subarray(0,128).toString().includes('ISO-10303-21'))throw error('invalid_artifact');
+      if(name.endsWith('.glb'))glbJson(body);
+      decoded.set(name,body);outputs.push({name,mediaType,bytes:body.length,sha256:hash(body)});
+    }
+    const verified=validateEngineeringArtifacts(decoded,expected);
+    for(const [name,body] of decoded)fs.writeFileSync(path.join(folder(job.id),name),body,{mode:0o600,flag:'wx'});
+    job.artifacts=outputs;job.assembly=verified.assembly;job.engineeringFit=verified.report;job.status='succeeded';save(job);
+  }
+  async function pump() {
+    if (pumping || closed) return;
+    pumping = true;
+    try {
+      for (const job of jobs.values()) {
+        if (closed || job.status !== 'queued') continue;
+        const controller = new AbortController(); controllers.set(job.id, controller);
+        const timer = setTimeout(() => { job.status = 'timed_out'; save(job); controller.abort(); }, timeoutMs);
+        try {
+          job.status = 'running'; save(job);
+          if(job.operation==='component_fit'){await runEngineering(job,controller.signal);continue;}
+          const expectedRevision=revisionExpected(job.scope,job.revision),source=effectiveSource(job.source,expectedRevision),sourceSha256=hash(source);
+          if(Buffer.byteLength(source)>128*1024)throw error('invalid_input');
+          const built = await sandbox(job.id, 'build', { mode: 'build', source, sourceSha256,...(expectedRevision?{revision:{...expectedRevision.summary,priorAssembly:expectedRevision.priorAssembly}}:{}) }, controller.signal);
+          if (controller.signal.aborted) throw error('interrupted');
+          // A revision build prefixes the prior source plus one boundary line; report lines of the patch itself.
+          const lineOffset = expectedRevision ? expectedRevision.priorSource.split('\n').length + 1 : 0;
+          if (built?.diagnostic) throw Object.assign(error('source_failed'), { diagnostic: failureDiagnostic(built.diagnostic, lineOffset) });
+          if (typeof built.step !== 'string' || built.step.length > 32 * 1024 * 1024 || !built.assembly || typeof built.assembly !== 'object' || !built.inspection || typeof built.inspection !== 'object' ||
+              Buffer.byteLength(JSON.stringify(built.inspection))>64*1024||built.assembly.inspectionPlanSha256!==hash(manifestCanonical(built.inspection))) throw error('invalid_artifact');
+          if(!Array.isArray(built.assembly.occurrences)||built.assembly.occurrences.some(item=>!item||!NODE_ID.test(item.occurrenceId??''))||
+            new Set(built.assembly.occurrences.map(item=>item.occurrenceId)).size!==built.assembly.occurrences.length)throw error('invalid_artifact');
+          expectedInspection(built.inspection,built.assembly);
+          validateRepresentation(built.representation,built.assembly);
+          validateInspectionGeometryTransport(built.inspection,built.assembly,built.inspectionGeometryBreps);
+          job.status = 'validating'; save(job);
+          const inspected = await sandbox(job.id, 'inspect', { mode: 'inspect', pass: job.pass, step: built.step, sourceSha256, assembly: built.assembly, inspection:built.inspection,revisionChecks:built.revisionChecks,
+            ...(built.representation?{representation:built.representation}:{}),
+            ...(built.inspectionGeometryBreps?{inspectionGeometryBreps:built.inspectionGeometryBreps}:{}),
+            ...(built.attachmentProposal?{attachmentProposal:built.attachmentProposal}:{}) }, controller.signal);
+          if (controller.signal.aborted) throw error('interrupted');
+          if (inspected?.diagnostic) throw Object.assign(error('source_failed'), { diagnostic: failureDiagnostic(inspected.diagnostic) });
+          const files = inspected.artifacts;
+          if (!files || typeof files !== 'object') throw error('invalid_artifact');
+          files['model.py'] = Buffer.from(source).toString('base64');
+          const outputs = [],decoded=new Map();
+          const types={...ARTIFACT_TYPES,...(built.attachmentProposal?{'attachment.json':'application/json'}:{})};
+          for (const [name, mediaType] of Object.entries(types)) {
+            const encoded = files[name];
+            if (typeof encoded !== 'string' || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw error('invalid_artifact');
+            const bytes = Buffer.from(encoded, 'base64');
+            const maximum = name.endsWith('.png') ? 4 * 1024 * 1024 : name.endsWith('.json') ? 128 * 1024 : 24 * 1024 * 1024;
+            if (!bytes.length || bytes.length > maximum) throw error('invalid_artifact');
+            if (name.endsWith('.png') && !bytes.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10]))) throw error('invalid_artifact');
+            if (name.endsWith('.glb')) glbJson(bytes);
+            if (name.endsWith('.step') && !bytes.subarray(0,128).toString().includes('ISO-10303-21')) throw error('invalid_artifact');
+            outputs.push({ name, mediaType, bytes: bytes.length, sha256: hash(bytes) });
+            decoded.set(name,bytes);
+          }
+          const assembly=validateAssembly(JSON.parse(decoded.get('assembly.json').toString('utf8')),sourceSha256,decoded.get('model.step'),decoded.get('model.glb'),decoded,expectedRevision);
+          validateInspection(JSON.parse(decoded.get('geometry.json').toString('utf8')),assembly,built.inspection,expectedRevision,built.representation);
+          if(built.attachmentProposal)job.attachment=validateAttachmentBaseline(JSON.parse(decoded.get('attachment.json')),assembly,decoded.get('model.step'));
+          for(const [name,file] of decoded)fs.writeFileSync(path.join(folder(job.id), name), file, { mode: 0o600, flag: 'wx' });
+          job.artifacts = outputs; job.assembly=assembly; job.status = 'succeeded'; save(job);
+        } catch (failure) {
+          atomic(path.join(folder(job.id),'private-failure.json'),{schema:'abelien.structure-private-failure.v1',at:new Date().toISOString(),message:failure?.message,stack:failure?.stack,diagnostic:failure?.diagnostic});
+          if (!['cancelled', 'timed_out', 'interrupted'].includes(job.status)) {
+            job.status = 'failed'; job.error = 'build_or_validation_failed';
+            if (failure?.diagnostic) job.diagnostic = failure.diagnostic;
+          }
+          job.artifacts = []; delete job.assembly; delete job.attachment; delete job.engineeringFit; save(job);
+        } finally { clearTimeout(timer); controllers.delete(job.id); }
+      }
+    } finally { pumping = false; if (!closed && [...jobs.values()].some(job => job.status === 'queued')) queueMicrotask(pump); }
+  }
+  return {
+    async restore() {
+      for (const id of fs.readdirSync(root).filter(id => UUID.test(id))) {
+        const job = JSON.parse(fs.readFileSync(path.join(folder(id), 'job.json'), 'utf8'));
+        if (job.id !== id || !HEX.test(job.scope)||!HEX.test(job.key??'')) throw error('corrupt_store');
+        const index=upstreamIndex(job.scope,job.key);if(keyIndex.has(index))throw error('corrupt_store');
+        keyIndex.set(index,id);
+        jobs.set(id, job);
+        if (['running', 'validating'].includes(job.status)) {
+          for (const phase of ['build', 'inspect']) await cleanup(containerName(id, phase));
+          job.status = 'interrupted'; job.artifacts = []; delete job.assembly; delete job.attachment; delete job.engineeringFit; save(job);
+        }
+      }
+      queueMicrotask(pump);
+    },
+    async submit(scope, input) {
+      requireScope(scope);
+      if(input?.operation==='component_fit'){
+        input=normalizeEngineeringFitRequest(input).input;
+        const digest=hash(canonical(input)),index=upstreamIndex(scope,input.key),existingId=keyIndex.get(index),existing=existingId?jobs.get(existingId):null;
+        if(existing){if(existing.digest!==digest)throw error('conflict');return publicJob(existing);}
+        if(closed||jobs.size>=maxJobs||[...jobs.values()].filter(j=>['queued','running','validating'].includes(j.status)).length>=32)throw error('queue_full');
+        fitExpected(scope,input.fit);
+        const job={...input,id:randomUUID(),scope,digest,status:'queued',createdAt:new Date().toISOString(),artifacts:[]};
+        fs.mkdirSync(folder(job.id),{mode:0o700});save(job);jobs.set(job.id,job);keyIndex.set(index,job.id);queueMicrotask(pump);return publicJob(job);
+      }
+      if (!input || typeof input !== 'object' || Object.keys(input).some(key => !['key','basis','title','pass','source','revision'].includes(key)) ||
+          !HEX.test(input.key ?? '') || !HEX.test(input.basis ?? '') || !['preview','final'].includes(input.pass) ||
+          typeof input.title !== 'string' || !input.title.trim() || input.title.length > 100 ||
+          typeof input.source !== 'string' || !input.source.trim() || Buffer.byteLength(input.source) > 32768) throw error('invalid_input');
+      input = { ...input,revision:normalizeRevisionInput(input.revision) }; // Freeze and normalize the server-resolved revision reference.
+      const digest = hash(JSON.stringify({ basis: input.basis, pass: input.pass, source: input.source, title: input.title,...(input.revision?{revision:input.revision}:{}) }));
+      const index=upstreamIndex(scope,input.key),existingId=keyIndex.get(index),existing=existingId?jobs.get(existingId):undefined;
+      if (existing) { if (existing.digest !== digest) throw error('conflict'); return publicJob(existing); }
+      if (closed || jobs.size >= maxJobs || [...jobs.values()].filter(job => ['queued','running','validating'].includes(job.status)).length >= 32) throw error('queue_full');
+      const expectedRevision=revisionExpected(scope,input.revision),source=effectiveSource(input.source,expectedRevision);
+      if(Buffer.byteLength(source)>128*1024)throw error('invalid_input');
+      if (preflightController) throw error('queue_full');
+      const controller = new AbortController(); preflightController = controller;
+      const timer = setTimeout(() => controller.abort(), preflightTimeoutMs);
+      try {
+        const result = await sandbox(randomUUID(), 'preflight', { mode: 'preflight', source,...(sourceApi?{sourceApi}:{}),...(build123dNames?{build123dNames}:{}) }, controller.signal);
+        if (controller.signal.aborted || closed) throw error('source_preflight_unavailable');
+        if (result?.ok !== true) {
+          const d = result?.diagnostic;
+          const diagnostic = d?.code === 'source_symbol'&&d.stage==='source_precheck'&&Number.isSafeInteger(d.line)&&d.line>=1&&d.line<=32768&&
+            typeof d.symbol==='string'&&/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*){0,3}$/.test(d.symbol)&&d.symbol.length<=192
+            ?{code:d.code,stage:d.stage,line:d.line,symbol:d.symbol}
+            : d?.code === 'source_unbound' && Array.isArray(d.names) && d.names.length <= 5 && d.names.every(name => typeof name === 'string' && /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(name))
+            ? { code: d.code, names: d.names }
+            : libraryDiagnostic(d) ?? (d?.code === 'source_syntax' && Number.isSafeInteger(d.line) && d.line >= 1 && d.line <= 32768 ? { code: d.code, line: d.line }
+            : d?.code === 'source_unsupported' && ['desktop_import','manual_export','missing_output','assembly_shape','import_unavailable'].includes(d.feature)
+              && Number.isSafeInteger(d.line) && d.line >= 1 && d.line <= 32768 ? {code:d.code,feature:d.feature,line:d.line} : undefined);
+          if (!diagnostic) throw error('source_preflight_unavailable');
+          throw Object.assign(error('source_invalid'), { diagnostic });
+        }
+      } catch (failure) {
+        if (failure?.code === 'source_invalid') throw failure;
+        throw error('source_preflight_unavailable');
+      } finally { clearTimeout(timer); preflightController = undefined; }
+      if (closed || jobs.size >= maxJobs) throw error('queue_full');
+      const job = { ...input, id: randomUUID(), scope, digest, status: 'queued', createdAt: new Date().toISOString(), artifacts: [] };
+      fs.mkdirSync(folder(job.id), { mode: 0o700 }); save(job);jobs.set(job.id, job);keyIndex.set(index,job.id);queueMicrotask(pump);
+      return publicJob(job);
+    },
+    list(scope) { requireScope(scope); return [...jobs.values()].filter(job => job.scope === scope).reverse().slice(0,30).map(publicJob); },
+    get(scope, id) { return publicJob(get(scope,id)); },
+    byUpstreamKey(scope,key){const id=keyIndex.get(upstreamIndex(scope,key));if(!id)throw error('not_found');return publicJob(get(scope,id));},
+    cancel(scope, id) {
+      const job = get(scope,id);
+      if (['queued','running','validating'].includes(job.status)) { job.status = 'cancelled'; job.artifacts = []; delete job.assembly; delete job.attachment; delete job.engineeringFit; save(job); controllers.get(id)?.abort(); }
+      return publicJob(job);
+    },
+    artifact(scope,id,name) {
+      const job = get(scope,id);
+      if (job.status !== 'succeeded' || !Object.hasOwn({...ARTIFACT_TYPES,...ENGINEERING_ARTIFACT_TYPES,'attachment.json':'application/json'},name)) throw error('not_found');
+      const asset = job.artifacts.find(asset => asset.name === name);if(!asset)throw error('not_found');
+      return { ...asset, body: readJobArtifact(job,name) };
+    },
+    close() {
+      closed = true;
+      preflightController?.abort();
+      for (const [id,controller] of controllers) { const job = jobs.get(id); job.status = 'interrupted'; save(job); controller.abort(); }
+    },
+  };
+}

package/skills/abelien-structure/worker/library-runtime.mjs

@@ -0,0 +1,15 @@
+/** Pure validation of the library signatures exported in T17's single installed-runtime manifest. */
+const same=(left,right)=>JSON.stringify(left)===JSON.stringify(right);
+
+export function validateCadLibraryIndex(index,library){
+  if(!library||typeof library.version!=='string'||!Array.isArray(library.functions)||
+    index?.version!==library.version||!Array.isArray(index.functions)||
+    !same(index.functions,library.functions.map(({name,params})=>({name,params}))))
+    throw new Error('structure_cad_library_invalid');
+  return index;
+}
+
+/** Names are always checked; the deeper T17 member/argument inference stays opt-in. */
+export function cadPreflightOptions(config,manifest){
+  return {build123dNames:manifest.moduleNames,...(config.sourceSymbolPrecheck?{sourceApi:manifest}:{})};
+}

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

@@ -0,0 +1,102 @@
+/** Authenticated service; one actual-runtime API/library export completes before accepting jobs; stdout is status-only. */
+import http from 'node:http';
+import {ENGINEERING_MAX_BODY_BYTES} from './engineering-fit.mjs';
+import { timingSafeEqual, createHash } from 'node:crypto';
+import { createJobQueue } from './jobs.mjs';
+import { createSandbox } from './sandbox.mjs';
+import { createNativeSandbox } from './native.mjs';
+import { acquireSupervisorLock, readWorkerConfig } from './supervisor.mjs';
+import {createWorkerIdentity,createWorkerSourceContract,resolveDockerImage,STRUCTURE_CHECKER_VERSION,STRUCTURE_PROTOCOL_VERSION} from './identity.mjs';
+import {STRUCTURE_SOURCE_CONTRACT_SCHEMA,prepareSourceApi} from './source-contract.mjs';
+import {cadPreflightOptions} from './library-runtime.mjs';
+import path from 'node:path';
+import {renderTargetComponentImage} from './component-target-image.mjs';
+import {MAX_GLB_BYTES} from './component-fit-glb.mjs';
+const hex=/^[a-f0-9]{64}$/;
+const TARGET_IMAGE_MAX_BODY_BYTES=Math.ceil(MAX_GLB_BYTES/3)*4+65536;
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+/** Data-only target render inside the Worker runtime; the private diagnostic goes back to the trusted host only. */
+async function targetImage(req,reply,renderer){
+  if(req.method!=='POST')return reply(405,{error:'method_not_allowed'});
+  if(req.headers['content-type']?.split(';')[0]!=='application/json')return reply(415,{error:'media_type'});
+  if(!renderer)return reply(503,{error:'target_renderer_unavailable'});
+  const chunks=[];let size=0;
+  for await(const chunk of req){size+=chunk.length;if(size>TARGET_IMAGE_MAX_BODY_BYTES)return reply(413,{error:'body_too_large'});chunks.push(chunk);}
+  let body;try{body=JSON.parse(Buffer.concat(chunks).toString('utf8'));}catch{return reply(400,{error:'invalid_input'});}
+  const glb=body?.baselineGlb,bytes=Buffer.from(typeof glb?.base64==='string'?glb.base64:'','base64');
+  if(!body||typeof body!=='object'||Array.isArray(body)||Object.keys(body).sort().join(',')!=='baseline,baselineGlb'
+    ||!bytes.length||!hex.test(glb.sha256??'')||sha256(bytes)!==glb.sha256)return reply(400,{error:'invalid_input'});
+  let diagnostic=null;
+  try{
+    const rendered=await renderer({baseline:body.baseline,baselineGlb:bytes},{onDiagnostic:event=>{diagnostic=event;}});
+    return reply(200,{provenance:rendered.provenance,diagnostic,png:{sha256:sha256(rendered.png),base64:rendered.png.toString('base64')},
+      targetGlb:{sha256:sha256(rendered.targetGlb),base64:rendered.targetGlb.toString('base64')}});
+  }catch(error){
+    const code=typeof error?.code==='string'&&/^[a-z][a-z0-9_]{0,47}$/.test(error.code)?error.code:'target_image_invalid';
+    return reply(code.startsWith('target_renderer_')?503:400,{error:code,diagnostic});
+  }
+}
+export function createHandler(queue, token, health={ok:true}, sourceContract=null, targetRenderer=null) {
+  const keys=Object.keys(health??{}).sort().join(','),legacy=keys==='ok'&&health?.ok===true;
+  const current=keys==='checkerVersion,ok,protocolVersion,runtimeDigest'&&health?.ok===true&&health.protocolVersion===STRUCTURE_PROTOCOL_VERSION&&
+    hex.test(health.runtimeDigest??'')&&health.checkerVersion===STRUCTURE_CHECKER_VERSION;
+  if(!legacy&&!current)throw new Error('structure_health_identity_invalid');
+  if(sourceContract!==null&&(!current||sourceContract.schema!==STRUCTURE_SOURCE_CONTRACT_SCHEMA))throw new Error('structure_source_contract_invalid');
+  const contract=sourceContract===null?null:JSON.parse(JSON.stringify(sourceContract));
+  const expected = Buffer.from(`Bearer ${token}`);
+  return async (req,res) => {
+    const reply = (status,value) => { res.writeHead(status, {'content-type':'application/json','cache-control':'no-store'}); res.end(JSON.stringify(value)); };
+    try {
+      const auth = Buffer.from(req.headers.authorization ?? '');
+      if (auth.length !== expected.length || !timingSafeEqual(auth,expected)) return reply(401,{error:'unauthorized'});
+      const url = new URL(req.url,'http://worker');
+      if (url.pathname === '/health' && req.method === 'GET') return reply(200,health);
+      if (url.pathname === '/source-contract' && req.method === 'GET')
+        return contract?reply(200,{health,contract}):reply(503,{error:'source_contract_unavailable'});
+      if (url.pathname === '/target-image') return targetImage(req,reply,targetRenderer);
+      const upstream=/^\/jobs\/by-upstream-key\/([a-f0-9]{64})$/.exec(url.pathname),scope=req.headers['x-structure-scope'];
+      if(upstream){if(req.method!=='GET')return reply(405,{error:'method_not_allowed'});return reply(200,queue.byUpstreamKey(scope,upstream[1]));}
+      const match = /^\/jobs(?:\/([a-f0-9-]+)(?:\/(cancel|artifacts\/([a-z.]+)))?)?$/.exec(url.pathname);
+      if (!match) return reply(404,{error:'not_found'});
+      if (req.method === 'GET') {
+        if (match[3]) {
+          const asset=queue.artifact(scope,match[1],match[3]);
+          res.writeHead(200,{'content-type':asset.mediaType,'content-length':asset.bytes,'x-content-sha256':asset.sha256,'cache-control':'no-store','x-content-type-options':'nosniff'});
+          return res.end(asset.body);
+        }
+        if (match[2]) return reply(405,{error:'method_not_allowed'});
+        return reply(200,match[1]?queue.get(scope,match[1]):{jobs:queue.list(scope)});
+      }
+      if (req.method !== 'POST' || (match[1] && match[2] !== 'cancel')) return reply(405,{error:'method_not_allowed'});
+      if (req.headers['content-type']?.split(';')[0] !== 'application/json') return reply(415,{error:'media_type'});
+      const chunks=[];let size=0;
+      for await(const chunk of req){size+=chunk.length;if(size>ENGINEERING_MAX_BODY_BYTES)return reply(413,{error:'body_too_large'});chunks.push(chunk);}
+      let body;try{body=JSON.parse(Buffer.concat(chunks).toString('utf8'));}catch{return reply(400,{error:'invalid_input'});}
+      if(size>65536&&body?.operation!=='component_fit')return reply(413,{error:'body_too_large'});
+      if(match[2]==='cancel') {
+        if(!body||typeof body!=='object'||Array.isArray(body)||Object.keys(body).length)return reply(400,{error:'invalid_input'});
+        return reply(200,queue.cancel(scope,match[1]));
+      }
+      return reply(202,await queue.submit(scope,body));
+    }catch(error){const code=error?.code,status={invalid_input:400,source_invalid:400,not_found:404,conflict:409,queue_full:429}[code]??503;reply(status,{error:status===503?'worker_unavailable':code,...(code==='source_invalid'?{diagnostic:error.diagnostic}:{})});}
+  };
+}
+if (process.argv[1]?.endsWith('/main.mjs')) {
+  const config=readWorkerConfig(process.env),release=acquireSupervisorLock(config.root);
+  process.once('exit', release);
+  const imageId=config.backend==='docker'?resolveDockerImage(config.image):undefined;
+  const sandbox=config.backend==='native-macos'
+    ?await createNativeSandbox({runtime:config.runtime,root:config.root})
+    :createSandbox(imageId);
+  const sourceApi=await prepareSourceApi(config,sandbox),runtimeConfig={...config,...(imageId?{imageId}:{}),...(sourceApi?{sourceApi}:{})};
+  const identity=createWorkerIdentity(runtimeConfig);
+  const queue=createJobQueue({root:config.root,sandbox,timeoutMs:config.timeoutMs,...cadPreflightOptions(config,sourceApi),...(sandbox.cleanup?{cleanup:sandbox.cleanup}:{})});
+  await queue.restore();
+  const targetRenderer=config.backend==='native-macos'
+    ?(input,options)=>renderTargetComponentImage(input,{...options,pythonPath:path.join(config.runtime,'venv/bin/python3')}):null;
+  const server=http.createServer(createHandler(queue,config.token,identity,createWorkerSourceContract(runtimeConfig),targetRenderer));
+  server.requestTimeout=15000;server.headersTimeout=10000;
+  server.listen(config.port,config.host,()=>console.log(`structure_worker_ready backend=${config.backend}`));
+  const stop=()=>{queue.close();server.close(()=>process.exit(0));setTimeout(()=>process.exit(0),10000).unref();};
+  process.on('SIGTERM',stop);process.on('SIGINT',stop);
+}

package/skills/abelien-structure/worker/manifest-digest.mjs

@@ -0,0 +1,11 @@
+/** Canonical cross-language geometry identities; Python uses IEEE-754 encoding too. */
+import {createHash} from 'node:crypto';
+export function manifestCanonical(value){
+  if(value===null)return 'null';
+  if(typeof value==='boolean'||typeof value==='string')return JSON.stringify(value);
+  if(typeof value==='number'&&Number.isFinite(value)){const b=Buffer.allocUnsafe(8);b.writeDoubleBE(value);return `#${b.toString('hex')}`;}
+  if(Array.isArray(value))return `[${value.map(manifestCanonical).join(',')}]`;
+  if(value&&typeof value==='object')return `{${Object.keys(value).sort().map(k=>`${JSON.stringify(k)}:${manifestCanonical(value[k])}`).join(',')}}`;
+  throw new Error('invalid_manifest_value');
+}
+export const manifestHash=value=>createHash('sha256').update(manifestCanonical(value)).digest('hex');