@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/mwi/legacy/edit-session.js

@@ -0,0 +1,50 @@
+// Declaration plans are immutable, workspace-bound read-back evidence, not UI input.
+import { randomUUID } from 'node:crypto';
+const fields = ['name','type','section','group','address','initial_value','description'];
+const plans = new Map();
+const ttl = 30 * 60 * 1000;
+export function variableExpectation(baseline, declaration, pou, existingGroups = baseline.map(v=>v.group)) {
+  if (!Array.isArray(baseline)) throw new Error('Missing saved declaration baseline');
+  if (!declaration || fields.some(f => !Object.hasOwn(declaration, f)
+      || (declaration[f] !== null && typeof declaration[f] !== 'string')))
+    throw new Error('Supply all seven declaration fields, using null for absent metadata');
+  if (!/^[A-Za-z_][A-Za-z0-9_]{0,29}$/.test(declaration.name ?? ''))
+    throw new Error('Use an IEC identifier of at most 30 characters; never silently truncate or rename');
+  if (!declaration.type || /[;\r\n]/.test(declaration.type)) throw new Error('Invalid data type');
+  if (!(pou ? ['VAR','VAR_INPUT','VAR_OUTPUT','VAR_IN_OUT','VAR_EXTERNAL'] : ['VAR_GLOBAL']).includes(declaration.section))
+    throw new Error('Usage does not match worksheet scope');
+  if (!declaration.group) throw new Error('An explicit existing variable group is required');
+  if (declaration.section === 'VAR_EXTERNAL' && (declaration.address || declaration.initial_value))
+    throw new Error('Externals must not duplicate a global physical address or initializer');
+  if (baseline.some(v => v.name.toUpperCase() === declaration.name.toUpperCase()))
+    throw new Error('Variable already exists; addition refused');
+  if (!existingGroups.includes(declaration.group))
+    throw new Error('Group is not in the saved baseline; create/verify it separately');
+  if (declaration.address && baseline.some(v => v.address?.toUpperCase() === declaration.address.toUpperCase()))
+    throw new Error('Exact IEC address already used; addition refused');
+  // Distinct strings can overlap physically. This is not an IO allocation proof.
+  return [...baseline.map(v => Object.fromEntries(fields.map(f => [f,v[f] ?? null]))), {...declaration}];
+}
+export function requireVariableView(view, pou) {
+  const expected = pou ? `/Pous/${pou}/${pou}V` : null;
+  if (!view || (expected ? view.toLowerCase() !== expected.toLowerCase()
+      : !/^\/Hardware\/[^/]+\/[^/]+\/Global_Variables$/i.test(view)))
+    throw new Error(`REFUSED: active worksheet '${view ?? ''}' is not the requested variable worksheet`);
+}
+export function retainPlan({workspace, project, pou, view, baseline, declaration}, now = Date.now()) {
+  requireVariableView(view,pou);
+  const expected = variableExpectation(baseline,declaration,pou);
+  const token = randomUUID();
+  for (const [id,p] of plans) if (now - p.created > ttl) plans.delete(id);
+  plans.set(token, structuredClone({workspace,project,pou:pou ?? null,view,baseline,expected,created:now}));
+  return {token, expected_count:expected.length, declaration:{...declaration},
+    dialog_values:{name:declaration.name,type:declaration.type,usage:declaration.section,
+      address:declaration.address ?? '',initial_value:declaration.initial_value ?? '',description:declaration.description ?? ''},
+    action_performed:false, expires_in_seconds:ttl/1000};
+}
+export function lookupPlan(token, workspace, now = Date.now()) {
+  const plan = plans.get(token);
+  if (!plan || plan.workspace !== workspace || now - plan.created > ttl)
+    throw new Error('REFUSED: declaration plan is missing, expired, or belongs to another workspace; do not reconstruct it from damaged read-back');
+  return structuredClone(plan);
+}

package/vendor/mwi/legacy/fb-insertion.js

@@ -0,0 +1,74 @@
+import {createHash} from 'node:crypto';
+const identifier=name=>typeof name==='string'&&/^[A-Za-z_][A-Za-z0-9_]{0,29}$/.test(name);
+const sameType=(a,b)=>a.replace(/\s+/g,'').toUpperCase()===b.replace(/\s+/g,'').toUpperCase();
+function expression(value){
+  if(typeof value!=='string'||!value.trim()||/[^\x20-\x7e]/.test(value))throw new Error('Binding must be one printable ASCII expression');
+  let quote=null;const stack=[];
+  for(let n=0;n<value.length;n++){
+    const c=value[n],pair=value.slice(n,n+2);
+    if(quote){if(c==='$'){n++;continue;}if(c===quote){if(value[n+1]===quote)n++;else quote=null;}continue;}
+    if(c==="'"||c==='"'){quote=c;continue;}
+    if(['(*','*)','//'].includes(pair)||/[;{}]/.test(c)||c===','&&!stack.length)throw new Error('Binding contains a statement/comment or extra argument');
+    if(c==='('||c==='[')stack.push(c);
+    if(c===')'||c===']'){if(stack.pop()!==(c===')'?'(':'['))throw new Error('Unbalanced binding expression');}
+  }
+  if(quote||stack.length)throw new Error('Unbalanced binding expression');
+  return value.trim();
+}
+function insertionPoint(body,offset){
+  if(!Number.isInteger(offset)||offset<0||offset>body.length||offset!==0&&offset!==body.length&&body[offset-1]!=='\n')throw new Error('offset must be a line boundary in expected_body');
+  let depth=0,quote=null,lineComment=false;
+  for(let n=0;n<offset;n++){
+    const c=body[n],pair=body.slice(n,n+2);
+    if(lineComment){if(c==='\n')lineComment=false;continue;}
+    if(depth){if(pair==='(*'){depth++;n++;}else if(pair==='*)'){depth--;n++;}continue;}
+    if(quote){if(c==='$'){n++;continue;}if(c===quote){if(body[n+1]===quote)n++;else quote=null;}continue;}
+    if(pair==='(*'){depth++;n++;}else if(pair==='//'){lineComment=true;n++;}else if(c==="'"||c==='"')quote=c;
+  }
+  if(depth||quote||lineComment)throw new Error('Insertion point is inside a comment/string');
+}
+export function fbInsertionPlan(args,block,read){
+  if(args.baseline_saved!==true||!identifier(args.instance))throw new Error('Saved baseline and valid new instance name required');
+  const compiled=block.evidence_kind==='fresh-bound-compiled-block-interface';
+  if(block.kind!=='FUNCTION_BLOCK'||block.hidden||!identifier(block.name)||!['installed-declared-block-interface','fresh-bound-compiled-block-interface'].includes(block.evidence_kind))throw new Error('Requires a visible, declared function-block interface or verified current compiled contract');
+  if(compiled&&(block.insertion_eligible!==true||block.project_compiler_freshness_verified!==true||block.compiler_library_binding_verified!==true||block.compiler_pin_types_verified!==true||block.compile_acceptance_only!==true||!Number.isFinite(block.verified_at_ms)||block.verified_at_ms>Date.now()||Date.now()-block.verified_at_ms>300000||! /^[a-f0-9]{64}$/.test(block.library_manifest_digest??'')||! /^[a-f0-9]{64}$/.test(block.source_baseline_digest??'')))throw new Error('Current compiled contract is incomplete or expired');
+  if(block.insertion_eligible===false)throw new Error('Diagnostic compiled interface is not insertion eligible; freshness/source binding remains unverified');
+  const hashMode=args.expected_body_sha256!==undefined;
+  if(hashMode&&(args.expected_body!==undefined||! /^[a-f0-9]{64}$/.test(args.expected_body_sha256)))throw new Error('Supply either exact expected_body or readable expected_body_sha256');
+  if(read.language!=='ST'||read.body_error||typeof read.body!=='string'||(hashMode?
+    createHash('sha256').update(read.body).digest('hex')!==args.expected_body_sha256:read.body!==args.expected_body))throw new Error('Exact saved ST expected_body/readable hash required');
+  if(/[^\x09\x0a\x0d\x20-\x7e]/.test(read.body))throw new Error('Native ST insertion currently requires printable ASCII source');
+  if(read.variables.some(v=>v.name.toUpperCase()===args.instance.toUpperCase()))throw new Error('Instance already declared');
+  const bindings=args.bindings??{},pins=new Map(block.pins.map(p=>[p.name.toUpperCase(),p]));
+  const seen=new Set(),fields=[],outputs=[],warnings=[];
+  for(const [name,input] of Object.entries(bindings)){
+    const pin=pins.get(name.toUpperCase());
+    if(!pin||seen.has(pin.name.toUpperCase()))throw new Error('Unknown or repeated pin: '+name);
+    seen.add(pin.name.toUpperCase());const value=expression(input);
+    const variable=read.variables.find(v=>v.name.toUpperCase()===value.toUpperCase());
+    if(pin.direction==='output'||pin.direction==='in_out'){
+      if(!identifier(value)||!variable)throw new Error('Output/in-out binding requires an existing direct variable: '+pin.name);
+      if(pin.type.toUpperCase()!=='ANY'&&!sameType(variable.type,pin.type))throw new Error('Binding type mismatch: '+pin.name);
+    }else if(pin.direction==='input'){
+      if(variable&&pin.type.toUpperCase()!=='ANY'&&!sameType(variable.type,pin.type))throw new Error('Binding type mismatch: '+pin.name);
+      if(!variable)warnings.push('Compiler must validate input expression type: '+pin.name);
+    }else throw new Error('Unresolved pin direction: '+pin.name);
+    // eCLR requires both sides of VAR_IN_OUT connected to the same variable.
+    // Installed help: TheVARINOUTParameterIsNotConnectedToAVariable.htm and
+    // TheVARINOUTParameterIsConnectedToDifferentVariables.htm.
+    if(pin.direction==='output'||pin.direction==='in_out')outputs.push(value+' := '+args.instance+'.'+pin.name+';\r\n');
+    if(pin.direction!=='output')fields.push(pin.name+' := '+value);
+  }
+  for(const pin of block.pins)if(pin.direction==='in_out'&&!seen.has(pin.name.toUpperCase()))throw new Error('Required in-out binding missing: '+pin.name);
+  let offset=args.offset??read.body.length;
+  if(args.before!==undefined){
+    if(args.offset!==undefined||typeof args.before!=='string'||!args.before)throw new Error('Use either a nonempty before anchor or offset');
+    offset=read.body.indexOf(args.before);
+    if(offset<0||read.body.indexOf(args.before,offset+1)>=0)throw new Error('before anchor must match exactly once');
+  }
+  insertionPoint(read.body,offset);
+  const call=args.instance+'('+fields.join(', ')+');\r\n'+outputs.join('');
+  const prefix=read.body.slice(0,offset),suffix=read.body.slice(offset);
+  return {declaration:{name:args.instance,type:block.name,section:'VAR',group:args.group??'Default',address:null,initial_value:null,description:null},
+    code:prefix+(prefix&&!prefix.endsWith('\n')?'\r\n':'')+call+suffix,call,offset,warnings,interface:block};
+}

package/vendor/mwi/legacy/native-code.js

@@ -0,0 +1,83 @@
+import {createHash} from 'node:crypto';
+const hash=text=>createHash('sha256').update(text).digest('hex');
+const stable=v=>JSON.stringify(v,(_k,x)=>x&&typeof x==='object'&&!Array.isArray(x)?Object.fromEntries(Object.keys(x).sort().map(k=>[k,x[k]])):x);
+const same=(a,b)=>stable(a)===stable(b);
+const canonical=text=>text.replace(/\r\n?/g,'\n');
+// Assemble small exact edits locally; never ask the model to reproduce the body.
+export function patchedCode(body,args){
+  if(!Array.isArray(args.changes)||args.changes.length===0||args.changes.length>50)throw new Error('Supply 1-50 exact code changes');
+  let code=canonical(body);
+  for(const change of args.changes){
+    if(!change||typeof change.find!=='string'||!change.find||typeof change.replace!=='string')throw new Error('Each change needs nonempty find and string replace');
+    const find=canonical(change.find),replacement=canonical(change.replace),count=change.count??1;
+    if(!Number.isInteger(count)||count<1||count>100)throw new Error('Change count must be 1-100');
+    const parts=code.split(find),actual=parts.length-1;
+    if(actual!==count)throw new Error(`Exact change expected ${count} occurrence(s), found ${actual}; nothing imported`);
+    code=parts.join(replacement);
+  }
+  return code;
+}
+const sorted=rows=>rows.sort((a,b)=>a.name.localeCompare(b.name));
+const inventory=s=>({pous:sorted(s.pous.map(({name,type})=>({name,type}))),tasks:sorted(s.tasks.map(({name,kind,instances})=>({name,kind,instances})))});
+export async function nativeCodeChange(args,deps){
+  if(args.baseline_saved!==true||(await deps.status()).is_modified!==false)throw new Error('Reconcile/save native edits before code import');
+  if(!/^[A-Za-z_][A-Za-z0-9_]{0,29}$/.test(args.pou??''))throw new Error('Invalid POU name');
+  const patchMode=args.changes!==undefined||args.expected_body_sha256!==undefined;
+  if(patchMode?(args.code!==undefined||args.expected_body!==undefined||! /^[a-f0-9]{64}$/.test(args.expected_body_sha256??'')):
+    (typeof args.code!=='string'||typeof args.expected_body!=='string'))throw new Error('Supply either expected_body + code, or expected_body_sha256 + changes');
+  const before=await deps.saved(),live=await deps.snapshot(),body=await deps.read();
+  const target=before.pous.find(p=>p.name.toLowerCase()===args.pou.toLowerCase());
+  const native=live.pous.find(p=>p.name.toLowerCase()===args.pou.toLowerCase());
+  const languages={ST:2,IL:1};
+  if(!target||!Object.hasOwn(languages,target.language)||!native||native.language!==languages[target.language]||native.read_only)throw new Error('Target must be an existing writable ST/IL POU with matching saved/native language');
+  if(!same(inventory(before),inventory(live)))throw new Error('Native/saved inventories disagree');
+  if(body.body_error||typeof body.body!=='string'||(patchMode?hash(body.body)!==args.expected_body_sha256:canonical(body.body)!==canonical(args.expected_body)))throw new Error('Saved code differs from expected_body/hash or cannot be resolved');
+  const desired=patchMode?patchedCode(body.body,args):args.code;
+  if(/[^\x09\x0a\x0d\x20-\x7e]/.test(desired))throw new Error('Supply printable ASCII ST/IL code');
+  const document=await deps.document();
+  const code=canonical(desired).replace(/\n/g,'\r\n');
+  const input_text=code&&!code.endsWith('\r\n')?code+'\r\n':code;
+  const declarations=await deps.declarations();
+  const input=await deps.prepare(input_text,target.language);
+  const request={pou:target.name,language:target.language,worksheet:document.urn.split('.').at(-1),before_native:live,before_files:before.file_hashes,before_declarations:declarations,input_text,...input};
+  await deps.retain({args,baseline:before,native_baseline:live,body_before:body.body,expected_body:input_text,request});
+  const result=await deps.mutate(request),after=await deps.saved(),read=await deps.read(),errors=[];
+  if(result.saved!==true||result.is_modified!==false)errors.push('Native save not proven');
+  if(!same(result.snapshot,live))errors.push('Native structure changed');
+  if(!same(await deps.declarations(),declarations))errors.push('Native declaration flags changed');
+  if(!same(before.globals,after.globals)||!same(before.tasks,after.tasks))errors.push('Globals/tasks changed');
+  if(!same(inventory(before),inventory(after)))errors.push('Saved structure changed');
+  for(const old of before.pous){
+    const current=after.pous.find(p=>p.name===old.name);
+    if(old.name!==target.name&&!same(old,current))errors.push('Unrelated POU changed: '+old.name);
+    if(old.name===target.name){
+      const omit=({body_sha256,body_blank,identifiers,...rest})=>rest;
+      if(!current||!same(omit(old),omit(current)))errors.push('Target declarations/metadata changed');
+    }
+  }
+  const targetFile='POE/'+target.name+'/src.st1';
+  const bodyExtension=target.language==='IL'?'.AB':'.STB';
+  if(!same(Object.keys(before.program_sources).sort(),Object.keys(after.program_sources).sort()))errors.push('Program source inventory changed');
+  const targetBefore=before.program_sources[targetFile]??{},targetAfter=after.program_sources[targetFile]??{};
+  const vb=Object.keys(targetBefore).find(name=>name.toUpperCase().endsWith('.VB'));
+  // Reading a new blank POU's native variable collection initializes its empty
+  // Default-group storage at the next Save. Permit only this observed header,
+  // with complete declarations, groups and raw native flags still unchanged.
+  const initialized_empty_storage=target.variables.length===0&&vb&&targetBefore[vb]===hash('')&&targetAfter[vb]===hash('\r\n(*Group:Default*)\r\n\r\n');
+  for(const [file,streams] of Object.entries(before.program_sources)){
+    const omitBody=rows=>Object.fromEntries(Object.entries(rows).filter(([name])=>!name.toUpperCase().endsWith(bodyExtension)&&!(initialized_empty_storage&&name.toUpperCase().endsWith('.VB'))&&!(initialized_empty_storage&&name.toUpperCase().endsWith('.VGR'))));
+    if(!same(file===targetFile?omitBody(streams):streams,file===targetFile?omitBody(after.program_sources[file]??{}):after.program_sources[file]))errors.push('Unexpected program stream change: '+file);
+  }
+  const translation='POE/'+target.name+'/'+request.worksheet+'Translation.xml';
+  const otherTranslations=rows=>Object.fromEntries(Object.entries(rows??{}).filter(([file])=>file.toLowerCase()!==translation.toLowerCase()));
+  const beforeComments=otherTranslations(before.translation_files),afterComments=otherTranslations(after.translation_files);
+  const emptyNewVariableTranslation='POE/'+target.name+'/'+document.variable_worksheet+'Translation.xml';
+  if(initialized_empty_storage){
+    for(const file of Object.keys(afterComments)){
+      if(!Object.hasOwn(beforeComments,file)&&file.toLowerCase()===emptyNewVariableTranslation.toLowerCase()&&after.empty_translation_files?.includes(file))delete afterComments[file];
+    }
+  }
+  if(!same(beforeComments,afterComments))errors.push('Unrelated comment translations changed');
+  if(read.body_error||typeof read.body!=='string'||canonical(read.body)!==canonical(input_text))errors.push('Saved code/comments differ from requested code');
+  return {pou:target.name,language:target.language,action_performed:true,method:'native_dde_ChangeCodeWS',native_result:result,verification:{accepted:errors.length===0,errors,initialized_empty_storage:!!initialized_empty_storage},body:read.body,baseline:before,saved_result:after,next_step:'Fresh Build/Make; compilation and controller acceptance are separate.'};
+}

package/vendor/mwi/legacy/native-groups.js

@@ -0,0 +1,75 @@
+import {isDeepStrictEqual as same} from 'node:util';
+const fields=['name','type','section','group','address','initial_value','description'];
+const flags=['retain','pdd','opc','disabled','not_on_plc','redundant'];
+const projection=rows=>rows.map(v=>Object.fromEntries(fields.map(k=>[k,k==='description'?(v[k]?.trim()||null):k==='group'?v[k]?.trim():v[k]??null]))).sort((a,b)=>a.name.localeCompare(b.name));
+const fold=name=>name.toLowerCase();
+export function groupPlan(args,before,live){
+ if(args.pou!==undefined&&(typeof args.pou!=='string'||!/^[A-Za-z_][A-Za-z0-9_]{0,29}$/.test(args.pou)))throw Error('Exact POU identifier required; omit pou only for globals');
+ if(!['create','rename','delete'].includes(args.operation))throw Error('Unsupported group operation');
+ if(typeof args.name!=='string'||!args.name.trim()||args.name.length>255||/[\x00-\x1f]/.test(args.name))throw Error('Exact nonempty group name required');
+ if(args.operation==='delete'&&args.user_approved!==true)throw Error('Explicit empty-group deletion approval required');
+ if(args.operation!=='rename'&&args.new_name!==undefined)throw Error('new_name applies only to rename');
+ const destination=args.operation==='rename'?args.new_name:args.name;
+ if(args.operation!=='delete'&&(typeof destination!=='string'||destination!==destination.trim()||!destination||destination.length>255||/[\x00-\x1f]/.test(destination)))throw Error('New group name must be nonempty, trimmed and contain no control characters');
+ if(!Array.isArray(live.variables)||!Array.isArray(live.groups)||live.groups.some(g=>typeof g.name!=='string'||!g.name.trim()||typeof g.read_only!=='boolean')||live.variables.some(v=>flags.some(k=>typeof v[k]!=='boolean')))throw Error('Complete native groups and declaration flags required');
+ if(new Set(live.groups.map(g=>fold(g.name.trim()))).size!==live.groups.length)throw Error('Ambiguous native group inventory');
+ const pou=args.pou?before.pous.find(p=>p.name===args.pou):null;
+ if(args.pou&&(!pou||live.structure.pous.find(p=>p.name===args.pou)?.read_only!==false))throw Error('Exact writable POU required');
+ const savedRows=args.pou?pou.variables:before.globals;
+ if(!same(projection(savedRows),projection(live.variables)))throw Error('Saved/native declarations disagree; no group action');
+ const inventories=rows=>rows.map(({name,type,language})=>({name,type,language})).sort((a,b)=>a.name.localeCompare(b.name));
+ if(!same(inventories(before.pous.map(p=>({...p,language:{IL:1,ST:2,FBD:3,LD:4}[p.language]}))),inventories(live.structure.pous)))throw Error('Saved/native POU inventories disagree');
+ const tasks=rows=>rows.map(({name,kind,instances})=>({name,kind,instances})).sort((a,b)=>a.name.localeCompare(b.name));
+ if(!same(tasks(before.tasks),tasks(live.structure.tasks)))throw Error('Saved/native task inventories disagree');
+ const sheets={globals:before.globals,...Object.fromEntries(before.pous.map(p=>['pou:'+p.name,p.variables]))};
+ if(!live.group_membership||!same(Object.keys(sheets).sort(),Object.keys(live.group_membership).sort()))throw Error('Complete native group membership inventory required');
+ for(const [key,rows] of Object.entries(sheets)){
+  const groups=live.group_membership[key];
+  if(!Array.isArray(groups)||groups.some(g=>typeof g.name!=='string'||!g.name.trim()||typeof g.read_only!=='boolean'||!Array.isArray(g.members)||g.members.some(name=>typeof name!=='string'||!name)))throw Error('Complete group metadata required');
+  if(new Set(groups.map(g=>fold(g.name.trim()))).size!==groups.length)throw Error('Ambiguous native group inventory: '+key);
+  const memberRows=groups.flatMap(g=>g.members.map(name=>({name,group:g.name.trim()}))).sort((a,b)=>a.name.localeCompare(b.name));
+  if(!same(memberRows,rows.map(v=>({name:v.name,group:v.group?.trim()})).sort((a,b)=>a.name.localeCompare(b.name))))throw Error('Saved/native group membership disagrees: '+key);
+ }
+ const key=args.pou?'pou:'+args.pou:'globals';
+ if(!same(live.group_membership[key].map(({name,read_only})=>({name,read_only})),live.groups))throw Error('Target group metadata disagrees');
+ const target=live.groups.find(g=>g.name===args.name);
+ if(args.operation==='create'&&live.groups.some(g=>fold(g.name)===fold(args.name)))throw Error('Group already exists');
+ if(args.operation!=='create'&&(!target||target.read_only!==false))throw Error('Exact writable group required');
+ if(args.operation==='rename'&&live.groups.some(g=>g!==target&&fold(g.name)===fold(destination)))throw Error('Destination group already exists');
+ if(args.operation==='rename'&&target.name===destination)throw Error('Group already has requested name');
+ const members=live.variables.filter(v=>v.group===args.name);
+ if(live.variables.some(v=>!live.groups.some(g=>g.name===v.group)))throw Error('Native variable has unknown group');
+ if(args.operation==='delete'&&(members.length||live.groups.length<=1))throw Error('Delete requires an empty group and another remaining group');
+ const expected=structuredClone(live),savedExpected=structuredClone(before);
+ if(args.operation==='create'){expected.groups.push({name:destination,read_only:false});expected.group_membership[key].push({name:destination,read_only:false,members:[]});}
+ if(args.operation==='delete'){expected.groups=expected.groups.filter(g=>g.name!==args.name);expected.group_membership[key]=expected.group_membership[key].filter(g=>g.name!==args.name);}
+ if(args.operation==='rename'){
+  expected.groups.find(g=>g.name===args.name).name=destination;
+  expected.group_membership[key].find(g=>g.name===args.name).name=destination;
+  for(const v of expected.variables)if(v.group===args.name)v.group=destination;
+  const names=new Set(members.map(v=>v.name));
+  for(const v of args.pou?savedExpected.pous.find(p=>p.name===args.pou).variables:savedExpected.globals)if(names.has(v.name)&&v.group?.trim()===args.name.trim())v.group=destination;
+ }
+ const prefix=args.pou?`poe/${args.pou.toLowerCase()}/`:'c/configuration/r/resource/';
+ const sources=Object.entries(before.program_sources).filter(([path])=>path.replaceAll('\\','/').toLowerCase().startsWith(prefix));
+ if(sources.length!==1)throw Error('Exact declaration source container required');
+ const [source,streams]=sources[0],vb=Object.keys(streams).filter(s=>s.toUpperCase().endsWith('.VB'));
+ if(vb.length!==1)throw Error('Exact variable worksheet stream required');
+ return {expected,savedExpected,members,source,allowed:new Set([vb[0],vb[0].slice(0,-3)+'.VGR'])};
+}
+export async function nativeGroupChange(args,deps){
+ if(args.baseline_saved!==true||(await deps.status()).is_modified!==false)throw Error('Reconcile/save native edits before group changes');
+ const before=await deps.saved(),live=await deps.snapshot(),plan=groupPlan(args,before,live);
+ await deps.retain({before,live,expected:plan.expected,members:plan.members,source:plan.source});
+ const result=await deps.mutate({...args,before_state:live,expected_state:plan.expected,before_files:before.file_hashes});
+ const after=await deps.saved(),nativeAfter=await deps.snapshot(),state=await deps.status(),errors=[];
+ if(result.saved!==true||result.is_modified!==false||state.is_modified!==false)errors.push('Native save completion unverified');
+ if(!same(plan.expected,nativeAfter))errors.push('Native groups, declaration flags, structure or libraries differ from plan');
+ for(const key of ['pous','tasks','globals','translation_files'])if(!same(plan.savedExpected[key],after[key]))errors.push('Saved '+key+' differs from plan');
+ for(const path of new Set([...Object.keys(before.program_sources),...Object.keys(after.program_sources)])){
+  const old=before.program_sources[path],now=after.program_sources[path];
+  if(path!==plan.source){if(!same(old,now))errors.push('Unrelated program streams changed: '+path);continue;}
+  for(const stream of new Set([...Object.keys(old??{}),...Object.keys(now??{})]))if(!plan.allowed.has(stream)&&old?.[stream]!==now?.[stream])errors.push('Unrelated worksheet stream changed: '+stream);
+ }
+ return {accepted:!errors.length,operation:args.operation,action_performed:true,member_count:plan.members.length,errors,before,after,native_before:live,native_after:nativeAfter};
+}

package/vendor/mwi/legacy/native-structure.js

@@ -0,0 +1,143 @@
+const eq=(a,b)=>a.toUpperCase()===b.toUpperCase();
+const stable=v=>JSON.stringify(v,(_k,x)=>x&&typeof x==='object'&&!Array.isArray(x)?Object.fromEntries(Object.keys(x).sort().map(k=>[k,x[k]])):x);
+const same=(a,b)=>stable(a)===stable(b);
+const sorted=rows=>[...rows].sort((a,b)=>a.name.localeCompare(b.name));
+const inventory=s=>({pous:sorted(s.pous.map(({name,type})=>({name,type}))),tasks:sorted(s.tasks.map(({name,kind,instances})=>({name,kind,instances})))});
+const identifier=(name,max=30)=>typeof name==='string'&&new RegExp(`^[A-Za-z_][A-Za-z0-9_]{0,${max-1}}$`).test(name);
+const byName=(rows,name)=>rows.find(r=>eq(r.name,name??''));
+function references(saved,name){
+  const found=[];
+  for(const p of saved.pous){
+    if(eq(p.name,name))continue;
+    // references_reviewed also covers graphical/indirect calls, which this
+    // saved ST scan cannot prove absent. Preserve that limitation in evidence.
+    if(p.identifiers.includes(name.toUpperCase())||p.variables.some(v=>new RegExp(`\\b${name}\\b`,'i').test(v.type)))found.push(p.name);
+  }
+  if(saved.globals.some(v=>new RegExp(`\\b${name}\\b`,'i').test(v.type)))found.push('resource globals');
+  if(saved.tasks.some(t=>t.instances.some(i=>eq(i.type,name))))found.push('task assignment');
+  return found;
+}
+export function structurePlan(scope,args,saved,live){
+  const native=structuredClone(live),op=args.operation;
+  if(!identifier(args.name,scope==='task'?7:30))throw new Error('Invalid native object name');
+  const target=byName(scope==='pou'?native.pous:native.tasks,args.name);
+  const plan={native,target,affected:[]};
+  if(scope==='pou'){
+    if(!['create','copy','rename','delete'].includes(op))throw new Error('Unknown POU operation');
+    if(op!=='create'&&args.language!==undefined)throw new Error('Language applies only to POU creation');
+    if(op==='create'){
+      if(target)throw new Error('POU already exists');
+      const type=args.pou_type??'PROGRAM';
+      if(!['PROGRAM','FUNCTION_BLOCK','FUNCTION'].includes(type))throw new Error('Unknown POU type');
+      if(type==='FUNCTION'&&!identifier(args.return_type))throw new Error('Function requires a simple explicit return type');
+      if(type!=='FUNCTION'&&args.return_type)throw new Error('Return type applies only to functions');
+      const language=args.language??'ST',languages={IL:1,ST:2,FBD:3,LD:4};
+      if(!Object.hasOwn(languages,language))throw new Error('Unsupported POU language');
+      native.pous.push({name:args.name,type,language:languages[language],plc_type:'',processor_type:'',read_only:false});
+      plan.affected=[args.name];
+    }else{
+      if(!target||target.read_only)throw new Error('POU missing or read-only');
+      if(op==='copy'||op==='rename'){
+        if(!identifier(args.new_name)||byName(native.pous,args.new_name))throw new Error('New POU name invalid or already exists');
+        plan.affected=[args.new_name,...(op==='rename'?[target.name]:[])];
+      }
+      if(op==='rename'||op==='delete'){
+        if(args.references_reviewed!==true||op==='delete'&&args.user_approved!==true)throw new Error('Explicit reference review/deletion approval required');
+        const refs=references(saved,target.name);
+        if(refs.length)throw new Error('POU has remaining references: '+refs.join(', '));
+      }
+      if(op==='copy')native.pous.push({...target,name:args.new_name});
+      if(op==='rename')target.name=args.new_name;
+      if(op==='delete'){native.pous=native.pous.filter(p=>p!==target);plan.affected=[target.name];}
+    }
+  }else{
+    if(!['create','edit','delete','assign','unassign'].includes(op))throw new Error('Unknown task operation');
+    if(op==='create'){
+      if(target)throw new Error('Task already exists');
+      const kind=args.kind??'CYCLIC';
+      if(!['CYCLIC','DEFAULT','SYSTEM'].includes(kind))throw new Error('Unknown task kind');
+      native.tasks.push({name:args.name,kind,instances:[]});
+    }else{
+      if(!target)throw new Error('Task missing');
+      if(op==='delete'){
+        if(args.user_approved!==true)throw new Error('Task deletion approval required');
+        if(target.instances.length)throw new Error('Unassign programs before deleting task');
+        native.tasks=native.tasks.filter(t=>t!==target);
+      }
+      if(op==='assign'){
+        const pou=byName(native.pous,args.pou),instance=args.instance??args.pou;
+        if(!pou||pou.type!=='PROGRAM'||!identifier(instance)||byName(target.instances,instance))throw new Error('Invalid program or duplicate instance');
+        target.instances.push({name:instance,type:pou.name});
+      }
+      if(op==='unassign'){
+        if(args.user_approved!==true)throw new Error('Unassignment approval required');
+        const instance=byName(target.instances,args.instance);
+        if(!instance)throw new Error('Exact instance missing');
+        target.instances=target.instances.filter(i=>i!==instance);
+      }
+      if(op==='edit'){
+        const old=byName(saved.tasks,args.name).settings,changes=args.settings_changes;
+        if(!changes||!Object.keys(changes).length)throw new Error('Supply task settings changes');
+        for(const [key,value] of Object.entries(changes)){
+          if(!Object.hasOwn(old,key)||typeof value!=='string'||/[^\x20-\x7e]|[,;():=]/.test(value))throw new Error('Unsupported task setting field/value');
+          if(key==='INTERVAL'&&(!/^T#[0-9]+(?:\.[0-9]+)?(?:ns|us|ms|s|m|h)$/i.test(value)||Number(value.slice(2).replace(/[a-z]+$/i,''))<=0))throw new Error('Invalid cyclic interval');
+          if(key==='PRIORITY'&&!/^\d+$/.test(value))throw new Error('Invalid task priority');
+          if(key==='WATCHDOG'&&!/^\d+$/.test(value))throw new Error('Invalid watchdog');
+          if(key==='WATCHDOG_ENABLED'&&!['YES','NO'].includes(value))throw new Error('Invalid watchdog state');
+        }
+        plan.settings={...old,...changes};
+        if(!['CYCLIC','DEFAULT','SYSTEM'].includes(plan.settings.TYPE))throw new Error('Invalid task type');
+        target.kind=plan.settings.TYPE;
+        plan.settings_text=`TASK ${target.name}\r\n(`+Object.entries(plan.settings).map(([k,v])=>`${k} := ${v}`).join(',\r\n')+'\r\n);\r\n';
+      }
+    }
+  }
+  return plan;
+}
+export async function nativeStructureChange(scope,args,{status,saved,snapshot,mutate,prepareSettings,retainPlan}){
+  if(args.baseline_saved!==true||(await status()).is_modified!==false)throw new Error('Reconcile/save native edits before structural changes');
+  const before=await saved(),live=await snapshot();
+  if(!same(inventory(before),inventory(live)))throw new Error('Saved and native structural inventories disagree');
+  const plan=structurePlan(scope,args,before,live);
+  const settings=plan.settings_text?await prepareSettings(plan.settings_text):{};
+  if(retainPlan)await retainPlan({scope,args,baseline:before,native_baseline:live,expected_native:plan.native,expected_settings:plan.settings});
+  const result=await mutate({...args,scope,before_native:live,before_files:before.file_hashes,expected_native:plan.native,...settings});
+  const after=await saved(),errors=[];
+  if(!same(result.snapshot,plan.native))errors.push('Complete native result differs from plan');
+  if(!same(inventory(after),inventory(plan.native)))errors.push('Saved structural inventory differs from plan');
+  if(result.saved!==true||result.is_modified!==false)errors.push('Native save not proven');
+  if(!same(before.globals,after.globals))errors.push('Global declarations changed unexpectedly');
+  for(const old of before.pous){
+    if(plan.affected.some(n=>eq(n,old.name)))continue;
+    if(!same(old,byName(after.pous,old.name)))errors.push('Unrelated POU changed: '+old.name);
+  }
+  const affectedFile=file=>plan.affected.some(n=>file.replace(/\\/g,'/').toLowerCase().startsWith('poe/'+n.toLowerCase()+'/'));
+  for(const file of new Set([...Object.keys(before.program_sources),...Object.keys(after.program_sources)])){
+    if(affectedFile(file))continue;
+    if(!same(before.program_sources[file],after.program_sources[file]))errors.push('Unrelated program streams changed: '+file);
+  }
+  for(const file of new Set([...Object.keys(before.translation_files??{}),...Object.keys(after.translation_files??{})])){
+    if(affectedFile(file))continue;
+    if(before.translation_files?.[file]!==after.translation_files?.[file])errors.push('Unrelated translation file changed: '+file);
+  }
+  if(scope==='pou'){
+    const created=byName(after.pous,args.operation==='create'?args.name:args.new_name);
+    if(args.operation==='create'&&(!created?.body_blank||created.variables.length||created.return_type!==(args.return_type??'')||created.language!==(args.language??'ST')))errors.push('New POU language/defaults/return type not proven');
+    if(['rename','copy'].includes(args.operation)){
+      const old=byName(before.pous,args.name);
+      if(!created||!same({...old,name:created.name},created))errors.push('Renamed/copied POU source differs from retained source');
+    }
+  }
+  for(const old of before.tasks){
+    if(scope==='task'&&eq(old.name,args.name))continue;
+    if(!same(old,byName(after.tasks,old.name)))errors.push('Unrelated task changed: '+old.name);
+  }
+  if(scope==='task'&&args.operation!=='delete'){
+    const actual=byName(after.tasks,args.name),old=byName(before.tasks,args.name);
+    const expected=plan.settings??old?.settings;
+    if(expected&&!same(expected,actual?.settings))errors.push('Task settings differ from plan');
+  }
+  return {scope,operation:args.operation,action_performed:true,native_result:result,verification:{accepted:!errors.length,errors},
+    baseline:before,saved_result:after,expected_native:plan.native,next_step:errors.length?'STOP: inspect retained evidence; no automatic retry/repair.':
+      scope==='pou'&&args.operation==='create'&&args.pou_type==='FUNCTION'?'Define the function VAR_INPUT interface and return logic before fresh Build/Make; a blank function is not a compiled implementation.':'Run fresh Build/Make after intended edits.'};
+}

package/vendor/mwi/legacy/native-variables.js

@@ -0,0 +1,77 @@
+import {variableExpectation} from './edit-session.js';
+const fields=['name','type','section','group','address','initial_value','description'];
+const flagFields=['retain','pdd','opc','disabled','not_on_plc','redundant'];
+const equalName=(a,b)=>a.toUpperCase()===b.toUpperCase();
+// The saved reader trims comment padding; raw native rows remain the mutation guard.
+const savedProjection=rows=>rows.map(v=>Object.fromEntries(fields.map(f=>[f,f==='description'?(v[f]?.trim()||null):v[f]??null])));
+export function variableChangePlan(baseline,args,existingGroups=baseline.map(v=>v.group)) {
+  if(!['add','edit','delete'].includes(args.operation))throw new Error('Unknown variable operation');
+  let old;
+  if(args.operation!=='add') {
+    old=baseline.find(v=>equalName(v.name,args.name??''));
+    if(!old)throw new Error('Target variable does not exist');
+  }
+  if(args.operation==='delete') {
+    if(args.user_approved!==true||args.references_reviewed!==true)throw new Error('Explicit deletion approval and reference review required');
+    return {expected:baseline.filter(v=>v!==old),old};
+  }
+  const declaration=args.declaration;
+  if(old && !equalName(old.name,declaration?.name??'') && args.rename_reviewed!==true)
+    throw new Error('Review all code/external references before renaming a declaration');
+  const rest=old?baseline.filter(v=>v!==old):baseline;
+  // Retain original group evidence even when editing its sole declaration.
+  const expected=variableExpectation(rest,declaration,args.pou,existingGroups);
+  return {expected,old};
+}
+export async function nativeVariableChange(args,{status,saved,snapshot,snapshotSaved,mutate,compare,globals}) {
+  if(args.flags!==undefined) {
+    if(!args.flags||typeof args.flags!=='object'||Array.isArray(args.flags)||Object.entries(args.flags).some(([k,v])=>!flagFields.includes(k)||typeof v!=='boolean'))throw new Error('flags must contain only explicit boolean native variable flags');
+    if(args.operation==='delete')throw new Error('Flag changes require add/edit, not delete');
+  }
+  if(args.baseline_saved!==true)throw new Error('Save/reconcile IDE edits before a native variable operation');
+  // The combined native read proves saved state before/after enumeration. It is
+  // fresh for this operation; the mutation still checks the complete baseline.
+  const combined=snapshotSaved?await snapshotSaved():null;
+  const state=snapshotSaved?combined:await status();
+  if(state?.is_modified!==false)throw new Error('Native project has unsaved or unknown changes; save/reconcile first');
+  const before=await saved();
+  if(before.warnings?.length)throw new Error('Saved declaration parse warnings; no native action performed');
+  const live=snapshotSaved?combined:await snapshot();
+  const nativeRows=savedProjection(live.variables);
+  const aligned=compare(before.variables,nativeRows);
+  if(!aligned.accepted)throw new Error('Live declarations disagree with saved baseline; no native action performed');
+  const plan=variableChangePlan(before.variables,args,live.groups.map(g=>g.name));
+  if(args.declaration?.section==='VAR_EXTERNAL') {
+    const global=await globals();
+    const match=global.variables.find(v=>equalName(v.name,args.declaration.name));
+    if(!match || match.type.toUpperCase()!==args.declaration.type.toUpperCase())throw new Error('External requires an existing global of the exact name/type');
+  }
+  const target=live.variables.find(v=>equalName(v.name,args.name??''));
+  const group=args.declaration?.group??target?.group;
+  if(!live.groups.some(g=>g.name===group&&!g.read_only))throw new Error('Target group is absent or read-only');
+  if(args.operation==='edit' && group!==target.group)throw new Error('Native Variable.Group is read-only; use the observed variable-grid move workflow in docs/VARIABLE_WORKSHEET_WORKFLOW.md and verify complete saved/native declarations');
+  const result=await mutate({...args,before_native:live.variables});
+  const after=await saved();
+  const verification=compare(plan.expected,after.variables);
+  if(!Array.isArray(result.variables)) {
+    verification.accepted=false;verification.errors.push('Complete native read-back is missing');
+  } else {
+    const nativeExpected=args.operation==='delete'?live.variables.filter(v=>v!==target):
+      [...live.variables.filter(v=>args.operation==='add'||v!==target),{...args.declaration}];
+    const nativeAfter=compare(nativeExpected,result.variables);
+    if(!nativeAfter.accepted){verification.accepted=false;verification.errors.push('Native read-back disagrees with expected declarations');}
+  }
+  if(result.saved!==true||result.is_modified!==false){verification.accepted=false;verification.errors.push('Native save completion not proven');}
+  for(const row of result.variables??[]) {
+    const original=live.variables.find(v=>equalName(v.name,row.name))??(plan.old&&equalName(row.name,args.declaration?.name??'')?target:null);
+    const changedTarget=args.operation!=='delete'&&equalName(row.name,args.declaration.name);
+    for(const field of flagFields) {
+      const expected=changedTarget&&Object.hasOwn(args.flags??{},field)?args.flags[field]:(original?.[field]??false);
+      if(row[field] !== expected){verification.accepted=false;verification.errors.push(`Native ${field} disagrees with expected flag on ${row.name}`);}
+    }
+  }
+  if(after.warnings?.length){verification.accepted=false;verification.errors.push(...after.warnings);}
+  return {operation:args.operation,action_performed:true,native_result:result,verification,
+    next_step:verification.accepted?'Run fresh Build/Make after the intended changes are complete.':'STOP: inspect retained before/after evidence; no automatic repair or retry.',
+    baseline:before.variables,expected_variables:plan.expected};
+}

package/vendor/mwi/legacy/pou-conversion.js

@@ -0,0 +1,47 @@
+import {isDeepStrictEqual as same} from 'node:util';
+import {alignSavedNative} from './pou-package.js';
+const sourceKeys=['pous','tasks','globals','program_sources','translation_files'];
+const exact=(saved,name)=>saved.pous.find(p=>p.name===name);
+const identical=(a,b)=>sourceKeys.every(k=>same(a[k],b[k]));
+const inside=(file,name)=>file.replaceAll('\\','/').toLowerCase().startsWith('poe/'+name.toLowerCase()+'/');
+
+// Native conversion replaces a POU's source language. It is never a text write
+// into a graphical container, and compile success does not prove canvas wiring.
+export async function convertPou(args,deps){
+ if(args.baseline_saved!==true||args.conversion_reviewed!==true)throw Error('Saved baseline and explicit conversion review required');
+ if(!/^[A-Za-z_][A-Za-z0-9_]{0,29}$/.test(args.pou??'')||!['FBD','LD'].includes(args.language))throw Error('Exact POU and FBD/LD destination required');
+ if(!/^[a-f0-9]{64}$/.test(args.expected_body_sha256??''))throw Error('Exact saved body SHA-256 required');
+ const state=await deps.status();if(state.is_modified!==false)throw Error('Unsaved or unknown native baseline');
+ const before=await deps.saved(),native=await deps.snapshot(),pou=exact(before,args.pou),meta=native.structure.pous.find(p=>p.name===args.pou);
+ alignSavedNative(before,native);
+ const flags=['retain','pdd','opc','disabled','not_on_plc','redundant'];
+ if(Object.values(native.declarations).some(sheet=>!Array.isArray(sheet.variables)||!Array.isArray(sheet.groups)||sheet.variables.some(v=>flags.some(k=>typeof v[k]!=='boolean'))||sheet.groups.some(g=>typeof g.read_only!=='boolean')))throw Error('Complete native declaration flags/groups are unknown');
+ if(!pou||!meta||meta.read_only!==false||!['ST','FBD','LD'].includes(pou.language)||pou.language===args.language)throw Error('Exact writable POU in a different supported language required');
+ if(pou.body_sha256!==args.expected_body_sha256)throw Error('Stale POU body; inspect current source before conversion');
+ const build_started_ms=Date.now();
+ const build=await deps.build(),compiled=await deps.saved(),compiledNative=await deps.snapshot(),compiledState=await deps.status();
+ if(!identical(before,compiled)||!same(native,compiledNative))throw Error('Fresh Build changed saved/native source baseline');
+ if(build.is_compiled!==true||build.evidence_kind!=='observed_compile_transition'||compiledState.is_compiled!==true||compiledState.is_modified!==false)throw Error('Fresh compiled saved state unverified');
+ const source=await deps.source();
+ if(source.pou!==args.pou||source.language!==pou.language||!Array.isArray(source.artifacts)||source.artifacts.length!==4||source.artifacts.some(a=>!Number.isFinite(a.modified_ms)||a.modified_ms<build_started_ms||a.modified_ms>Date.now()))throw Error('Exact source POU compiler artifacts were not regenerated during this Build');
+ const result=await deps.mutate({pou:args.pou,language:args.language,before_state:compiledNative,before_files:compiled.file_hashes});
+ const after=await deps.saved(),afterNative=await deps.snapshot(),afterState=await deps.status(),errors=[];
+ const converted=exact(after,args.pou);
+ if(result.name!==args.pou||result.saved!==true||result.language!==({FBD:3,LD:4}[args.language])||afterState.is_modified!==false)errors.push('Native conversion/save not proven');
+ if(!converted||converted.language!==args.language||converted.type!==pou.type||converted.return_type!==pou.return_type||!same(converted.variables,pou.variables))errors.push('Converted language/type/declarations differ from plan');
+ if(pou.body_blank===false&&converted?.body_blank!==false)errors.push('Populated source became blank');
+ if(!same(before.pous.filter(p=>p.name!==args.pou),after.pous.filter(p=>p.name!==args.pou)))errors.push('Unrelated POU changed');
+ for(const key of ['tasks','globals'])if(!same(before[key],after[key]))errors.push('Unrelated '+key+' changed');
+ for(const key of ['program_sources','translation_files'])for(const file of new Set([...Object.keys(before[key]),...Object.keys(after[key])])){
+  if(!inside(file,args.pou)&&!same(before[key][file],after[key][file]))errors.push('Unrelated source/translation changed: '+file);
+ }
+ const expectedNative=structuredClone(native);expectedNative.structure.pous.find(p=>p.name===args.pou).language=({FBD:3,LD:4}[args.language]);
+ if(!same(expectedNative,afterNative))errors.push('Native inventory, libraries, groups or declaration flags differ from plan');
+ const verification={accepted:!errors.length,errors};
+ if(errors.length)return {verification,result,build,before,after,native_before:native,native_after:afterNative};
+ // A separate fresh Build verifies the generated graphical source, with all
+ // artifact identities and source preservation checked by graphicalListing.
+ const listing=await deps.listing(),final=await deps.saved(),finalNative=await deps.snapshot();
+ if(listing.accepted!==true||listing.compiler_cache_freshness_verified!==true||!identical(after,final)||!same(afterNative,finalNative))throw Error('Converted source compilation/listing or final native preservation unverified');
+ return {verification,result,build,source,build_started_ms,listing,before,after,native_before:native,native_after:afterNative,layout_verified:false,wiring_verified:false};
+}