@feng0531/dsh-code-review 0.79.0 → 0.80.2

package/src/svn-working-identity.mjs

@@ -1,9 +1,10 @@
 import {hash} from './content.mjs';
+import {sameSvnUrl,canonicalSvnUrl} from './svn-url.mjs';
 export function svnWorkingIdentity(node,rootInfo,name){
  const expected=name==='.'?rootInfo.url:rootInfo.url.replace(/\/$/,'')+'/'+name.split('/').map(encodeURIComponent).join('/');
- const sameUrl=(a,b)=>{try{const x=new URL(a),y=new URL(b);return x.protocol===y.protocol&&x.host===y.host&&x.username===y.username&&x.password===y.password&&decodeURIComponent(x.pathname)===decodeURIComponent(y.pathname)&&x.search===y.search&&x.hash===y.hash;}catch{return false;}};
- if(!sameUrl(node?.url,expected))throw Object.assign(new Error('SVN node URL differs from selected working-copy path; switched ancestors are unsupported'),{code:'SVN_SWITCHED_ANCESTOR'});
+
+ if(!sameSvnUrl(node?.url,expected))throw Object.assign(new Error('SVN node URL differs from selected working-copy path; switched ancestors are unsupported'),{code:'SVN_SWITCHED_ANCESTOR'});
  if(!rootInfo.repository?.uuid||node.repository?.uuid!==rootInfo.repository.uuid||node.repository?.root!==rootInfo.repository.root||node['wc-info']?.['wcroot-abspath']!==rootInfo['wc-info']?.['wcroot-abspath'])throw Object.assign(new Error('SVN node repository or working-copy identity mismatch'),{code:'SVN_NODE_IDENTITY'});
- const source={url:node.url,repositoryUuid:node.repository.uuid,repositoryRoot:node.repository.root,revision:String(node['@_revision']),kind:node['@_kind'],schedule:node['wc-info']?.schedule,copyFromUrl:node['wc-info']?.['copy-from-url']??null,copyFromRevision:node['wc-info']?.['copy-from-rev']??null};
+ const source={url:canonicalSvnUrl(node.url),repositoryUuid:node.repository.uuid,repositoryRoot:node.repository.root,revision:String(node['@_revision']),kind:node['@_kind'],...(node['@_kind']==='dir'?{depth:node['wc-info']?.depth??null}:{}),schedule:node['wc-info']?.schedule,copyFromUrl:node['wc-info']?.['copy-from-url']??null,copyFromRevision:node['wc-info']?.['copy-from-rev']??null};
  return {source,fingerprint:hash(JSON.stringify(source))};
 }

package/src/svn-working-mergeinfo.mjs

@@ -0,0 +1,31 @@
+import {checked} from './process.mjs';
+import {xml} from './svn.mjs';
+import {hash} from './content.mjs';
+import {svnWorkingIdentity} from './svn-working-identity.mjs';
+import {captureEffectiveMergeinfo} from './svn-effective-mergeinfo.mjs';
+
+export async function workingEffectiveMergeinfo(root,rootInfo,files,options={}){
+ const signal=AbortSignal.any([AbortSignal.timeout(30000),...(options.signal?[options.signal]:[])]);let commands=0,bytes=0;const cache=new Map();
+ const run=async args=>{signal.throwIfAborted();if(++commands>512)throw new Error('SVN working mergeinfo command budget exceeded');const data=await checked('svn',['--non-interactive',...args],{...options,cwd:root,signal,maxBytes:256*1024});bytes+=data.length;if(bytes>1024*1024)throw new Error('SVN working mergeinfo metadata budget exceeded');return xml(data);};
+ const read=async(name,side,revision)=>{
+  const key=JSON.stringify([name,side]);if(cache.has(key)){const value=cache.get(key);if(side==='old'&&value.source.revision!==revision)throw new Error('Mixed BASE revisions cannot prove effective mergeinfo');return value;}
+  const node=(await run(['info','--xml','--',name+'@'])).info?.entry?.[0];const identity=svnWorkingIdentity(node,rootInfo,name);
+  const entries=(await run(['status','--xml','--verbose','--ignore-externals','--depth','empty','--',name+'@'])).status?.target?.flatMap(t=>t.entry??[])??[];const state=entries[0]?.['wc-status'];
+  if(entries.length!==1||!state||['@_switched','@_file-external','@_tree-conflicted','@_copied'].some(k=>state[k]==='true')||!['normal','modified','deleted'].includes(state['@_item'])||state['@_props']==='conflicted')throw new Error('Unsafe ancestor state for effective mergeinfo');
+  if(side==='old'&&String(node['@_revision'])!==revision)throw new Error('Mixed BASE revisions cannot prove effective mergeinfo');
+  const props=(await run(['proplist','--xml','--verbose',...(side==='old'?['-r','BASE']:[]),'--',name+'@'])).properties?.target?.[0]?.property??[];const values=Object.create(null);
+  for(const p of props){if(typeof p['@_name']!=='string'||p['@_encoding']||Object.hasOwn(values,p['@_name']))throw new Error('Unsafe effective mergeinfo property representation');values[p['@_name']]=p['#text']??'';}
+  if(Object.hasOwn(values,'svn:externals')||Object.hasOwn(values,'svn:special'))throw new Error('Unsafe ancestor properties for effective mergeinfo');
+  const source={...identity.source,side,revision:String(node['@_revision']),propertyHash:hash(JSON.stringify(Object.entries(values).sort()))};
+  const record={path:name,present:Object.hasOwn(values,'svn:mergeinfo'),...(Object.hasOwn(values,'svn:mergeinfo')?{value:values['svn:mergeinfo']}:{}),identity:hash(JSON.stringify(source)),source};cache.set(key,record);return record;
+ };
+ const results=[];
+ for(const file of files.filter(f=>f.eligibility==='reviewable')){const value={path:file.path};for(const side of ['old','new']){
+   if(side==='old'&&['added','unversioned'].includes(file.rawStatus)||side==='new'&&file.rawStatus==='deleted'){value[side]={status:'absent',sources:[]};continue;}
+   if(file.replacementTreeRoot||file.replacementSource||file.copySource||file.targetAddition||file.rawStatus==='unversioned'){value[side]={status:'unknown',reason:'Added/copied/untracked ancestor semantics require separate provenance',sources:[]};continue;}
+   try{value[side]=await captureEffectiveMergeinfo(file.path,{signal,boundary:'.',complete:rootInfo.url===rootInfo.repository.root,read:name=>read(name,side,String(file.baseRevision))});for(const evidence of value[side].evidence??[])evidence.source=cache.get(JSON.stringify([evidence.path,side])).source;}catch(error){signal.throwIfAborted();if(error.code==='SVN_CAPTURE_BUDGET'||/budget exceeded/.test(error.message))throw error;value[side]={status:'unknown',reason:error.message,sources:[]};}
+  }results.push(value);}
+ // Re-read every captured property/identity after collection, charging same budget.
+ const original=[...cache.entries()];cache.clear();for(const [key,record]of original){const [name,side]=JSON.parse(key);if((await read(name,side,record.source.revision)).identity!==record.identity)throw new Error('Effective working mergeinfo changed during capture');}
+ return results;
+}

package/src/svn-working-scope.mjs

@@ -0,0 +1,7 @@
+// Describes observed evidence only; never infers a complete working tree from status.
+export function workingScopeEvidence(rootSource,files){
+ const revisions=[...new Set(files.filter(f=>f.eligibility==='reviewable'&&f.workingSource&&/^[0-9]+$/.test(f.workingSource.revision)).map(f=>f.workingSource.revision))].sort((a,b)=>Number(a)-Number(b));
+ const sparse=files.filter(f=>f.workingSource?.kind==='dir'&&f.workingSource.depth!=='infinity').map(f=>({path:f.path,depth:f.workingSource.depth??'unknown'}));
+ if(rootSource.depth!=='infinity'&&!sparse.some(s=>s.path==='.'))sparse.unshift({path:'.',depth:rootSource.depth??'unknown'});
+ return {root:rootSource,observedBaseRevisions:revisions,mixedObservedRevisions:revisions.length>1,sparseDirectories:sparse,inventoryComplete:false,notice:'Only selected/observed change metadata is described. Mixed revisions bind each node BASE independently, not a common historical tree. Sparse or unenumerated paths are not deletion evidence or reviewed coverage; no update/deepen/external traversal was performed.'};
+}

package/src/svn-working-special.mjs

@@ -0,0 +1,24 @@
+import {lstat,readlink,realpath} from 'node:fs/promises';
+import path from 'node:path';
+import {relativePath,readLocal,decode} from './content.mjs';
+import {assertNonSecretPath} from './secret-path.mjs';
+import {svnSpecialData} from './svn-special.mjs';
+
+// Validate ancestors but never realpath/open a symbolic-link leaf or its target.
+export async function readWorkingSvnSpecial(root,name,properties,options={}){
+ relativePath(name);assertNonSecretPath(name);options.signal?.throwIfAborted();
+ const canonical=await realpath(root);let cursor=canonical;const parts=name.split('/');
+ for(const part of parts.slice(0,-1)){cursor=path.join(cursor,part);const stat=await lstat(cursor);if(stat.isSymbolicLink()||!stat.isDirectory())throw new Error('SVN special ancestor must be a real directory');}
+ const filename=path.join(cursor,parts.at(-1)),before=await lstat(filename);let content;
+ if(before.isSymbolicLink()){
+  const target=await readlink(filename,{encoding:'buffer'});if(target.length>16384)throw new Error('SVN link target byte limit exceeded');
+  const bytes=Buffer.concat([Buffer.from('link '),target]);if(bytes.length>(options.maxFileBytes??256*1024))throw new Error('SVN special file size limit exceeded');
+  content=decode(bytes);const after=await lstat(filename);const again=await readlink(filename,{encoding:'buffer'});
+  if(!after.isSymbolicLink()||before.ino!==after.ino||before.mtimeMs!==after.mtimeMs||before.ctimeMs!==after.ctimeMs||!again.equals(target))throw new Error('SVN link changed during capture');
+ }else{
+  if(!before.isFile())throw new Error('SVN special working node is neither link nor regular link record');
+  content=await readLocal(canonical,name,options);
+ }
+ options.signal?.throwIfAborted();
+ return {content,special:svnSpecialData(content,properties,'file')};
+}

package/src/svn.mjs

@@ -1,3 +1,9 @@
+import {captureReplacementTree} from './svn-replacement-tree.mjs';
+import {readReplacementSource} from './svn-replacement-source.mjs';
+import {workingScopeEvidence} from './svn-working-scope.mjs';
+import {workingEffectiveMergeinfo} from './svn-working-mergeinfo.mjs';
+import {svnSpecialData} from './svn-special.mjs';
+import {readWorkingSvnSpecial} from './svn-working-special.mjs';
 import {svnWorkingIdentity} from './svn-working-identity.mjs';
 import { isSecretPath } from './secret-path.mjs';
 import { svnStateIssue } from './svn-state.mjs';
@@ -10,7 +16,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { XMLParser, XMLValidator } from 'fast-xml-parser';
 import { checked } from './process.mjs';
 import { hash, decode, readLocal, relativePath } from './content.mjs';
-const parser = new XMLParser({ ignoreAttributes: false, parseTagValue: false, parseAttributeValue: false, trimValues: false, isArray: name => ['entry', 'target', 'property'].includes(name) });
+const parser = new XMLParser({ htmlEntities: {}, ignoreAttributes: false, parseTagValue: false, parseAttributeValue: false, trimValues: false, isArray: name => ['entry', 'target', 'property'].includes(name) });
 export function xml(bytes) {
   const source = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
   if (/<!DOCTYPE|<!ENTITY/i.test(source) || XMLValidator.validate(source) !== true) throw new Error('Unsafe or invalid SVN XML');
@@ -67,14 +73,21 @@ export async function captureSvn(cwd, options = {}) {
   if (originalEntries.length > maxFiles) throw new Error('Change count limit exceeded');
   const entries = await structuralEntries(root, originalEntries, options, maxFiles);
   const known = new Set(entries.map(e => e['@_path'].replaceAll('\\', '/')));
-  if (selectedPaths?.some(p => !known.has(p))) throw new Error('Selected path is not a current change');
-  const files = [];
+  if (selectedPaths?.some(p => !known.has(p)&&!(options.svnReplacementBaseRevision!==undefined&&entries.some(e=>e['wc-status']?.['@_item']==='replaced'&&p.startsWith(e['@_path'].replaceAll('\\','/')+'/'))))) throw new Error('Selected path is not a current change');
+  const files = [],replacementTrees=[];
+  const replacementRoots=options.svnReplacementBaseRevision===undefined?[]:entries.filter(e=>e['wc-status']?.['@_item']==='replaced').map(e=>e['@_path'].replaceAll('\\','/')).sort().filter((p,i,all)=>!all.slice(0,i).some(parent=>p.startsWith(parent+'/')));
+  for(const name of replacementRoots){
+    if(isSecretPath(name))continue;
+    if(options.selectedPaths&&!options.selectedPaths.some(p=>p===name||p.startsWith(name+'/')))continue;
+    const tree=await captureReplacementTree(root,rootInfo,name,options);replacementTrees.push(tree);files.push(...tree.files);if(files.length>maxFiles)throw new Error('Combined replacement change count limit exceeded');
+  }
   for (const entry of entries) {
     signal?.throwIfAborted();
     const name = entry['@_path'].replaceAll('\\', '/');
+    if(replacementTrees.some(tree=>tree.files.some(f=>name===f.replacementTreeRoot||name.startsWith(f.replacementTreeRoot+'/'))))continue;
     const state = entry['wc-status'], status = state['@_item'];
     const item = { id: hash(name), path: name, ...(name === '.' ? {kind: 'dir'} : {}), rawStatus: status, baseRevision: state['@_revision'], eligibility: 'reviewable', properties: [] };
-    files.push(item);
+    files.push(item);if(files.length>maxFiles)throw new Error('Combined change count limit exceeded');
     if (isSecretPath(name)) { item.eligibility='excluded'; item.reason='Credential path excluded'; continue; }
     if ((selectedPaths && !selectedPaths.includes(name)) || (status === 'unversioned' && !selectedPaths?.includes(name))) {
       item.eligibility = 'excluded'; item.reason = 'Not explicitly selected'; continue;
@@ -82,7 +95,8 @@ export async function captureSvn(cwd, options = {}) {
     try {
       if (name !== '.') relativePath(name);
       const copiedDescendant = !!entry.copyRoot && ['normal', 'modified', 'added'].includes(status) && state['@_copied'] === 'true';
-      const issue = svnStateIssue(copiedDescendant ? {...state, '@_item':'added'} : state);
+      const independentReplacement=status==='replaced'&&options.svnReplacementBaseRevision!==undefined;
+      const issue = svnStateIssue(independentReplacement?{...state,'@_item':'modified','@_copied':'false'}:copiedDescendant ? {...state, '@_item':'added'} : state);
       if (issue) { item.blockCode = issue.code; throw new Error(issue.reason); }
       const hasBase = !copiedDescendant && !['added', 'unversioned'].includes(status);
       let kind;
@@ -92,7 +106,7 @@ export async function captureSvn(cwd, options = {}) {
         const identity=svnWorkingIdentity(node,rootInfo,name);
         item.workingSource=identity.source;item.workingIdentity=identity.fingerprint;
         kind = node['@_kind'];
-        if (state['@_copied'] === 'true' || node['wc-info']?.['copy-from-url']) {
+        if (!independentReplacement&&(state['@_copied'] === 'true' || node['wc-info']?.['copy-from-url'])) {
           let source = node['wc-info']?.['copy-from-url'], revision = node['wc-info']?.['copy-from-rev'];
           if (!source && copiedDescendant) {
             const parent = files.find(file => file.path === entry.copyRoot);
@@ -111,35 +125,48 @@ export async function captureSvn(cwd, options = {}) {
       item.kind = kind;
       if (copiedDescendant) item.targetAddition = true;
       item.rightExists = status !== 'deleted';
-      const leftProps = hasBase ? await properties(root, name, true, options) : {};
+      if(independentReplacement&&!['file','dir'].includes(kind))throw new Error('Unsupported replacement target kind');
+      const replacement=independentReplacement?await readReplacementSource(root,rootInfo,name,options.svnReplacementBaseRevision,options):null;
+      if(replacement?.descendants.length){item.blockCode='SVN_REPLACEMENT_OLD_DESCENDANTS';throw new Error('Replacement old directory descendants require separate dual-side tree capture; no implicit old child approval');}
+      if(replacement&&kind==='dir'){
+        const inventory=xml(await svn(root,['status','--xml','--verbose','--ignore-externals','--depth','infinity','--',target(name)],options)).status?.target?.flatMap(t=>t.entry??[])??[];
+        const descendants=inventory.filter(entry=>entry['@_path'].replaceAll('\\','/')!==name);
+        if(descendants.length||item.workingSource.depth!=='infinity'){item.blockCode='SVN_REPLACEMENT_NEW_DESCENDANTS';throw new Error('Replacement target directory is nonempty or sparse; descendants require separate node approval');}
+        item.replacementEmptyDirectory=true;
+      }
+      if(replacement){item.oldKind=replacement.kind;item.newKind=kind;item.nodeNotice='Independent fixed repository baseline and current target have separate node kinds; directories are not empty source files.';item.baseRevision=replacement.source.operativeRevision;item.replacementSource=replacement.source;item.contentNotice='Explicit repository revision baseline versus replacement working target; not local BASE, copy-source content, or proof that selected revision equals the removed node.';}
+      const leftProps = replacement?replacement.props:hasBase ? await properties(root, name, true, options) : {};
       const rightProps = status === 'deleted' || status === 'unversioned' ? {} : await properties(root, name, false, options);
-      if ('svn:special' in leftProps || 'svn:special' in rightProps) throw new Error('SVN special nodes are excluded');
+      if(kind!=='file'&&('svn:special' in leftProps||'svn:special' in rightProps))throw new Error('SVN special property requires file-node link data');
       const keywordText=!!(leftProps['svn:keywords']||rightProps['svn:keywords']);
-      if(keywordText&&kind!=='file')throw new Error('SVN keyword mapping requires regular file');
+      if(keywordText&&(kind!=='file'||replacement&&replacement.kind!=='file'))throw new Error('SVN keyword mapping requires regular file');
       item.textNotice = 'Text preserves SVN cat output and working bytes. CRLF/LF differences alone are not code defects.';
       for (const key of [...new Set([...Object.keys(leftProps), ...Object.keys(rightProps)])].sort()) {
         if (leftProps[key] !== rightProps[key]) item.properties.push({ name: key, old: leftProps[key] ?? null, new: rightProps[key] ?? null });
       }
       item.propertyIdentity = hash(JSON.stringify([leftProps, rightProps]));
-      if (kind === 'dir') {
+      if (kind === 'dir'&&(!replacement||replacement.kind==='dir')) {
         if (status === 'unversioned') throw new Error('Unversioned directory requires explicit descendant tracking');
         if (status === 'deleted' || status === 'added' || copiedDescendant) {
           const descendants = entries.filter(entry => entry['@_path'].replaceAll('\\', '/').startsWith(name + '/')).map(entry => entry['@_path'].replaceAll('\\', '/'));
           if (selectedPaths && descendants.some(child => !selectedPaths.includes(child))) throw new Error('Directory descendants are not all explicitly selected');
+          if(item.workingSource?.depth!=='infinity'){item.blockCode='SVN_SPARSE_STRUCTURE';throw new Error('Sparse or unknown directory depth cannot prove complete structural descendant coverage');}
           item.structuralDescendants = descendants;
           item.structuralNotice = 'Directory node coverage is separate from each descendant; no implicit descendant approval.';
         }
-        item.left = decode(Buffer.alloc(0)); item.right = decode(Buffer.alloc(0));
+        item.left = replacement?replacement.content:decode(Buffer.alloc(0)); item.right = decode(Buffer.alloc(0));
       } else {
-        item.left = decode(hasBase ? await svn(root, ['cat', '-r', 'BASE', '--', target(name)], { ...options, maxBytes: maxFileBytes }) : Buffer.alloc(0));
-        item.right = status === 'deleted' ? decode(Buffer.alloc(0)) : await readLocal(root, name, options);
+        item.left = replacement?replacement.content:decode(hasBase ? await svn(root, ['cat', '-r', 'BASE', '--', target(name)], { ...options, maxBytes: maxFileBytes }) : Buffer.alloc(0));
+        item.right = status === 'deleted'||kind==='dir' ? decode(Buffer.alloc(0)) : Object.hasOwn(rightProps,'svn:special')?(await readWorkingSvnSpecial(root,name,rightProps,options)).content:await readLocal(root, name, options);
+        const oldSpecial=svnSpecialData(item.left,leftProps,replacement?.kind??kind),newSpecial=svnSpecialData(item.right,rightProps,kind);
+        if(oldSpecial||newSpecial){item.specialData={old:oldSpecial,new:newSpecial};item.contentNotice='SVN link record data only on special sides; target strings authorize no target reads or source navigation.';}
         if(Object.hasOwn(leftProps,'svn:eol-style')||Object.hasOwn(rightProps,'svn:eol-style')){
           item.eolMapping={old:svnEolMapping(item.left.text,leftProps['svn:eol-style']??null),new:svnEolMapping(item.right.text,rightProps['svn:eol-style']??null)};
           item.textNotice+=' EOL mapping is hash-only metadata; raw text and LF evidence lines are authoritative. Lone CR has no identity mapping to normalized LF lines.';
         }
         if(keywordText){
           const old=svnKeywordMapping(item.left.text,leftProps['svn:keywords']??''),current=svnKeywordMapping(item.right.text,rightProps['svn:keywords']??'');
-          if(hasBase){
+          if(hasBase&&!replacement){
             const repository=decode(await svn(root,['cat','--ignore-keywords','-r','BASE','--',target(name)],{...options,maxBytes:maxFileBytes}));
             if(old.text!==repository.text)throw new Error('SVN BASE keyword mapping differs from repository text');
           }
@@ -149,7 +176,7 @@ export async function captureSvn(cwd, options = {}) {
         }
       }
     } catch (error) {
-      signal?.throwIfAborted(); item.eligibility = 'blocked'; item.reason = error.message;if(error.code)item.blockCode=error.code;
+      signal?.throwIfAborted();if(error.code==='SVN_CAPTURE_BUDGET')throw error; item.eligibility = 'blocked'; item.reason = error.message;if(error.code)item.blockCode=error.code;
       delete item.left; delete item.right;
     }
   }
@@ -163,21 +190,31 @@ export async function captureSvn(cwd, options = {}) {
       delete item.left; delete item.right;
     }
   }
-  for (const item of files.filter(f => f.eligibility === 'reviewable')) {
+  for (const item of files.filter(f => f.eligibility === 'reviewable'&&!f.replacementTreeRoot)) {
     if(item.workingIdentity){const node=xml(await svn(root,['info','--xml','--',target(item.path)],options)).info.entry[0];if(svnWorkingIdentity(node,rootInfo,item.path).fingerprint!==item.workingIdentity)throw new Error('SVN node identity changed during capture');}
+    if(item.replacementEmptyDirectory){const inventory=xml(await svn(root,['status','--xml','--verbose','--ignore-externals','--depth','infinity','--',target(item.path)],options)).status?.target?.flatMap(t=>t.entry??[])??[];if(inventory.some(e=>e['@_path'].replaceAll('\\','/')!==item.path))throw new Error('Replacement target directory inventory changed during capture');}
     if (item.copySource) {
       const node = xml(await svn(root, ['info', '--xml', '--', target(item.path)], options)).info.entry[0];
       const identity = hash(JSON.stringify([node.url, node['@_kind'], node['@_revision'], node['wc-info']?.schedule, node['wc-info']?.['wcroot-abspath'], node['wc-info']?.['copy-from-url'] ?? null, node['wc-info']?.['copy-from-rev'] ?? null, node.repository]));
       if (identity !== item.copyNodeIdentity) throw new Error('Copy source identity changed during capture');
     }
-    if (item.kind === 'file' && item.rawStatus !== 'deleted' && (await readLocal(root, item.path, options)).hash !== item.right.hash) throw new Error('Content changed during capture');
-    const left = !item.targetAddition && !['added', 'unversioned'].includes(item.rawStatus) ? await properties(root, item.path, true, options) : {};
+    if(item.kind==='file'&&item.rawStatus!=='deleted'){
+      const current=item.specialData?.new?(await readWorkingSvnSpecial(root,item.path,await properties(root,item.path,false,options),options)).content:await readLocal(root,item.path,options);
+      if(current.hash!==item.right.hash)throw new Error('Content changed during capture');
+    }
+    const replacement=item.replacementSource?await readReplacementSource(root,rootInfo,item.path,options.svnReplacementBaseRevision,options):null;
+    if(replacement&&JSON.stringify(replacement.source)!==JSON.stringify(item.replacementSource))throw new Error('Replacement repository baseline changed during capture');
+    const left = replacement?replacement.props:!item.targetAddition && !['added', 'unversioned'].includes(item.rawStatus) ? await properties(root, item.path, true, options) : {};
     const right = ['deleted', 'unversioned'].includes(item.rawStatus) ? {} : await properties(root, item.path, false, options);
     if (hash(JSON.stringify([left, right])) !== item.propertyIdentity) throw new Error('Properties changed during capture');
   }
+  for(const tree of replacementTrees)await tree.verify();
   const finalRootInfo=xml(await svn(root,['info','--xml','--','.@'],options)).info.entry[0];
   if(svnWorkingIdentity(finalRootInfo,rootInfo,'.').fingerprint!==svnWorkingIdentity(rootInfo,rootInfo,'.').fingerprint)throw new Error('SVN root identity changed during capture');
+  if(options.svnEffectiveMergeinfo!==undefined&&typeof options.svnEffectiveMergeinfo!=='boolean')throw new Error('Invalid SVN effective mergeinfo opt-in');
+  const effectiveMergeSources=options.svnEffectiveMergeinfo===true?await workingEffectiveMergeinfo(root,rootInfo,files,options):undefined;
   const mergeSources = snapshotMergeSources(files);
-  const snapshot = { schemaVersion: 1, vcs: 'svn', root, repositoryUuid: rootInfo.repository.uuid, repositoryUrl:rootInfo.url, ...(mergeSources.length ? {mergeSources} : {}), files };
+  const workingScope=workingScopeEvidence(svnWorkingIdentity(rootInfo,rootInfo,'.').source,files);
+  const snapshot = { schemaVersion: 1, vcs: 'svn', root, workingScope, repositoryUuid: rootInfo.repository.uuid, repositoryUrl:rootInfo.url,...(effectiveMergeSources?{effectiveMergeSources}:{}), ...(mergeSources.length ? {mergeSources} : {}), files };
   return { ...snapshot, id: hash(JSON.stringify(snapshot)) };
 }