@feng0531/dsh-code-review 0.83.0 → 0.84.0

package/src/snapshot.mjs

@@ -1,9 +1,9 @@
-import {createSvnCaptureBudget} from './svn-capture-budget.mjs';
-import {captureSvnDependencyChain} from './svn-dependency-chain.mjs';
-import {createSvnNavigationBudget} from './svn-navigation-budget.mjs';
-import {captureSvnExplicitContext} from './svn-explicit-context.mjs';
-import {captureDependencyChain} from './dependency-chain.mjs';
-import {captureSvnCallers} from './svn-caller-capture.mjs';
+import { createSvnCaptureBudget } from './svn-capture-budget.mjs';
+import { captureSvnDependencyChain } from './svn-dependency-chain.mjs';
+import { createSvnNavigationBudget } from './svn-navigation-budget.mjs';
+import { captureSvnExplicitContext } from './svn-explicit-context.mjs';
+import { captureDependencyChain } from './dependency-chain.mjs';
+import { captureSvnCallers } from './svn-caller-capture.mjs';
 import { captureCallers } from './caller-capture.mjs';
 import { validateCallerScopes } from './caller-index.mjs';
 import { bindBusinessRequirement, validateBusinessRequirement } from './business-requirement.mjs';
@@ -16,6 +16,7 @@ import { captureProjectRules } from './project-rules.mjs';
 import { captureSvn } from './svn.mjs';
 import { captureSvnHistory } from './svn-history.mjs';
 import { readLocal, relativePath, hash } from './content.mjs';
+import { CHANGE_SCOPES } from './git-change-scope.mjs';
 
 export async function detectVcs(cwd) {
   let current = await realpath(cwd);
@@ -32,7 +33,8 @@ export async function detectVcs(cwd) {
     current = parent;
   }
 }
-export async function captureSnapshot(cwd, options = {}) {
+
+function validateSnapshotOptions(options) {
   validateBusinessRequirement(options.businessRequirement);
   const { rulePaths = [], contextPaths = [], maxContextFiles = 20, maxSnapshotBytes = 4 * 1024 * 1024 } = options;
   for (const value of [maxContextFiles, maxSnapshotBytes]) if (!Number.isSafeInteger(value) || value < 1) throw new Error('Invalid snapshot limit');
@@ -42,77 +44,107 @@ export async function captureSnapshot(cwd, options = {}) {
   if (options.callerScopePaths !== undefined) validateCallerScopes(options.callerScopePaths);
   if (options.oldContextPaths !== undefined && (!Array.isArray(options.oldContextPaths) || options.oldContextPaths.length > 20 || new Set(options.oldContextPaths).size !== options.oldContextPaths.length)) throw new Error('Invalid old context paths');
   for (const name of options.oldContextPaths ?? []) relativePath(name);
+  return { rulePaths, contextPaths, maxContextFiles, maxSnapshotBytes };
+}
+
+export async function captureSnapshot(cwd, options = {}) {
+  const { rulePaths, contextPaths, maxContextFiles, maxSnapshotBytes } = validateSnapshotOptions(options);
+
   const type = await detectVcs(cwd);
-  if(options.svnReplacementBaseRevision!==undefined||options.svnReplacementAllowNetwork!==undefined){
-    if(type!=='svn'||['svnRevision','svnBaseRevision','svnTargetRevision','svnBasePath','svnTargetPath','commit','baseRevision','targetRevision'].some(key=>options[key]!==undefined))throw new Error('Replacement repository baseline requires SVN working-copy mode');
-    if(typeof options.svnReplacementBaseRevision!=='string'||!/^(0|[1-9][0-9]*)$/.test(options.svnReplacementBaseRevision)||!Number.isSafeInteger(Number(options.svnReplacementBaseRevision)))throw new Error('Replacement baseline requires fixed numeric revision');
-    if(options.svnReplacementAllowNetwork!==undefined&&typeof options.svnReplacementAllowNetwork!=='boolean')throw new Error('Invalid replacement network permission');
+  if (options.changeScope !== undefined) {
+    if (typeof options.changeScope !== 'string' || !CHANGE_SCOPES.includes(options.changeScope)) throw new Error('Invalid changeScope; expected worktree, staged or unstaged');
+    if (['commit', 'baseRevision', 'targetRevision', 'svnRevision', 'svnBaseRevision', 'svnTargetRevision', 'svnBasePath', 'svnTargetPath'].some(key => options[key] !== undefined)) throw new Error('changeScope applies to Git working-copy comparison only');
+    if (type !== 'git') throw new Error('changeScope requires a Git working copy');
+  }
+  const replacementOptions = options.svnReplacementBaseRevision !== undefined || options.svnReplacementAllowNetwork !== undefined;
+  if (replacementOptions) {
+    if (type !== 'svn' || ['svnRevision', 'svnBaseRevision', 'svnTargetRevision', 'svnBasePath', 'svnTargetPath', 'commit', 'baseRevision', 'targetRevision'].some(key => options[key] !== undefined)) throw new Error('Replacement repository baseline requires SVN working-copy mode');
+    if (typeof options.svnReplacementBaseRevision !== 'string' || !/^(0|[1-9][0-9]*)$/.test(options.svnReplacementBaseRevision) || !Number.isSafeInteger(Number(options.svnReplacementBaseRevision))) throw new Error('Replacement baseline requires fixed numeric revision');
+    if (options.svnReplacementAllowNetwork !== undefined && typeof options.svnReplacementAllowNetwork !== 'boolean') throw new Error('Invalid replacement network permission');
   }
-  if(options.svnEffectiveMergeinfo!==undefined&&type!=='svn')throw new Error('Effective SVN mergeinfo requires SVN repository');
-  if (['svnRevision','svnBaseRevision','svnTargetRevision','svnAllowNetwork','svnBasePath','svnTargetPath'].some(key=>options[key]!==undefined)) {
-    if (type!=='svn') throw new Error('SVN revision parameters require SVN working copy');
-    return bindBusinessRequirement(await captureSvnHistory(cwd,options),options.businessRequirement);
+  if (options.svnEffectiveMergeinfo !== undefined && type !== 'svn') throw new Error('Effective SVN mergeinfo requires SVN repository');
+  if (['svnRevision', 'svnBaseRevision', 'svnTargetRevision', 'svnAllowNetwork', 'svnBasePath', 'svnTargetPath'].some(key => options[key] !== undefined)) {
+    if (type !== 'svn') throw new Error('SVN revision parameters require SVN working copy');
+    return bindBusinessRequirement(await captureSvnHistory(cwd, options), options.businessRequirement);
   }
-  if (options.oldContextPaths !== undefined && (type !== 'git' || !['commit','baseRevision','targetRevision'].some(k => options[k] !== undefined))) throw new Error('Old context requires Git historical review');
-  if (['commit','baseRevision','targetRevision'].some(k => options[k] !== undefined)) {
+  if (options.oldContextPaths !== undefined && (type !== 'git' || !['commit', 'baseRevision', 'targetRevision'].some(k => options[k] !== undefined))) throw new Error('Old context requires Git historical review');
+  if (['commit', 'baseRevision', 'targetRevision'].some(k => options[k] !== undefined)) {
     if (type !== 'git') throw new Error('Git revision review is unsupported on SVN');
-    return bindBusinessRequirement(await captureGitHistory(cwd, options),options.businessRequirement);
+    return bindBusinessRequirement(await captureGitHistory(cwd, options), options.businessRequirement);
+  }
+
+  if (type === 'svn') {
+    const budget = createSvnCaptureBudget(options.signal);
+    options = { ...options, signal: budget.signal, svnCaptureBudget: budget };
   }
-  if(type==='svn'){const budget=createSvnCaptureBudget(options.signal);options={...options,signal:budget.signal,svnCaptureBudget:budget};}
   const capture = type === 'git' ? captureGit : captureSvn;
   const snapshot = await capture(cwd, options);
   if (!Array.isArray(rulePaths) || rulePaths.some(name => contextPaths.includes(name))) throw new Error('Rule paths must be separate from context paths');
   const rules = await captureProjectRules(snapshot.root, rulePaths, { signal: options.signal, files: snapshot.files });
-  const navigationBudget=type==='svn'?createSvnNavigationBudget(options.signal):undefined;
-  const navigationOptions=navigationBudget?{...options,signal:navigationBudget.signal,svnNavigationBudget:navigationBudget}:options;
+  const navigationBudget = type === 'svn' ? createSvnNavigationBudget(options.signal) : undefined;
+  const navigationOptions = navigationBudget ? { ...options, signal: navigationBudget.signal, svnNavigationBudget: navigationBudget } : options;
+
   const context = [];
   let autoContext, index, verifyDependencies, explicitSeeds = [], indexOptions = options;
-  if (options.autoContext === true && type==='git') {
-    const chain=await captureDependencyChain(snapshot.root,snapshot.files,options);
-    explicitSeeds=chain.explicitSeeds;context.push(...chain.context);autoContext=chain.autoContext;index=chain.index;indexOptions=chain.indexOptions;
+  if (options.autoContext === true && type === 'git') {
+    const chain = await captureDependencyChain(snapshot.root, snapshot.files, options);
+    explicitSeeds = chain.explicitSeeds;
+    context.push(...chain.context);
+    autoContext = chain.autoContext;
+    index = chain.index;
+    indexOptions = chain.indexOptions;
   } else if (options.autoContext === true) {
-    const chain=await captureSvnDependencyChain(snapshot.root,snapshot.files,navigationOptions);
-    explicitSeeds=chain.explicitSeeds;context.push(...chain.context);autoContext=chain.autoContext;indexOptions=chain.indexOptions;verifyDependencies=chain.verify;
+    const chain = await captureSvnDependencyChain(snapshot.root, snapshot.files, navigationOptions);
+    explicitSeeds = chain.explicitSeeds;
+    context.push(...chain.context);
+    autoContext = chain.autoContext;
+    indexOptions = chain.indexOptions;
+    verifyDependencies = chain.verify;
   }
   let verifyExplicit;
-  if(type==='svn'&&options.autoContext!==true&&contextPaths.length){
-    const explicit=await captureSvnExplicitContext(snapshot.root,[...new Set(contextPaths)].filter(name=>!snapshot.files.some(f=>f.path===name)).sort(),navigationOptions);
-    explicitSeeds=explicit.context;verifyExplicit=explicit.verify;indexOptions=explicit.options;
+  if (type === 'svn' && options.autoContext !== true && contextPaths.length) {
+    const explicit = await captureSvnExplicitContext(snapshot.root, [...new Set(contextPaths)].filter(name => !snapshot.files.some(f => f.path === name)).sort(), navigationOptions);
+    explicitSeeds = explicit.context;
+    verifyExplicit = explicit.verify;
+    indexOptions = explicit.options;
   }
+
   for (const name of [...new Set(contextPaths)].sort()) {
     const changed = snapshot.files.find(f => f.path === name);
     if (changed) {
       if (changed.eligibility !== 'reviewable') throw new Error('Context path is an excluded or blocked change');
       if (changed.rightExists === false) throw new Error('Deleted path cannot be working context');
-      if(changed.specialData)throw new Error('SVN link records cannot be working source context');
-      context.push({ path: name, ...changed.right,...(changed.eolMapping?.new?{eolMapping:structuredClone(changed.eolMapping.new)}:{}) });
+      if (changed.specialData) throw new Error('SVN link records cannot be working source context');
+      context.push({ path: name, ...changed.right, ...(changed.eolMapping?.new ? { eolMapping: structuredClone(changed.eolMapping.new) } : {}) });
     } else {
-      const seed=explicitSeeds.find(c=>c.path===name);
-      const item=type==='svn'&&options.autoContext!==true&&seed?structuredClone(seed):{path:name,...await readLocal(snapshot.root,name,indexOptions)};
-      if(seed&&seed.hash!==item.hash)throw new Error('Explicit dependency seed changed during capture');
-      if(seed?.eolMapping)item.eolMapping=structuredClone(seed.eolMapping);
-      if(seed?.keywordMapping)item.keywordMapping=structuredClone(seed.keywordMapping);
+      const seed = explicitSeeds.find(c => c.path === name);
+      const item = type === 'svn' && options.autoContext !== true && seed ? structuredClone(seed) : { path: name, ...await readLocal(snapshot.root, name, indexOptions) };
+      if (seed && seed.hash !== item.hash) throw new Error('Explicit dependency seed changed during capture');
+      if (seed?.eolMapping) item.eolMapping = structuredClone(seed.eolMapping);
+      if (seed?.keywordMapping) item.keywordMapping = structuredClone(seed.keywordMapping);
       context.push(item);
     }
   }
+
   let callerDiscovery, verifyCallers;
   if (options.callerScopePaths !== undefined) {
-    const callers = await (type==='git'?captureCallers:captureSvnCallers)(snapshot.root, snapshot.files, options.callerScopePaths, type==='svn'?navigationOptions:options);
+    const callers = await (type === 'git' ? captureCallers : captureSvnCallers)(snapshot.root, snapshot.files, options.callerScopePaths, type === 'svn' ? navigationOptions : options);
     verifyCallers = callers.verify;
     callerDiscovery = { ...callers.discovery, capturedPaths: [] };
     for (const item of callers.context) {
       const present = context.find(c => c.path === item.path);
       const matches = callerDiscovery.candidates.filter(c => c.fromPath === item.path);
       if (present && present.hash !== item.hash) throw new Error('Caller context changed during capture');
-      if (!present && context.length >= Math.min(maxContextFiles,20)) {
-        for (const candidate of matches) { candidate.status='blocked'; candidate.captureReason='Context file limit exceeded'; }
+      if (!present && context.length >= Math.min(maxContextFiles, 20)) {
+        for (const candidate of matches) { candidate.status = 'blocked'; candidate.captureReason = 'Context file limit exceeded'; }
         continue;
       }
       if (!present) context.push(item);
       callerDiscovery.capturedPaths.push(item.path);
-      for (const candidate of matches) candidate.status='captured';
+      for (const candidate of matches) candidate.status = 'captured';
     }
   }
+
   // Re-capture verifies both selected sides while collecting explicit context.
   if ((await capture(cwd, indexOptions)).id !== snapshot.id) throw new Error('Snapshot changed while collecting context');
   for (const item of context) if ((await readLocal(snapshot.root, item.path, indexOptions)).hash !== item.hash) throw new Error('Context changed during capture');
@@ -122,9 +154,10 @@ export async function captureSnapshot(cwd, options = {}) {
   if (verifyExplicit) await verifyExplicit();
   if (verifyDependencies) await verifyDependencies();
   if (verifyCallers) await verifyCallers();
-  const result = { ...snapshot, context, ...(callerDiscovery ? {callerDiscovery} : {}), ...(autoContext ? { autoContext } : {}), ...(rules.length ? { rules } : {}) };
+
+  const result = { ...snapshot, context, ...(callerDiscovery ? { callerDiscovery } : {}), ...(autoContext ? { autoContext } : {}), ...(rules.length ? { rules } : {}) };
   delete result.id;
   const serialized = JSON.stringify(result);
   if (Buffer.byteLength(serialized) > maxSnapshotBytes) throw new Error('Snapshot size limit exceeded');
-  return bindBusinessRequirement({ ...result, id: hash(serialized) },options.businessRequirement);
+  return bindBusinessRequirement({ ...result, id: hash(serialized) }, options.businessRequirement);
 }

package/src/svn-capture-budget.mjs

@@ -1,7 +1,24 @@
-import {captureSignal} from './capture-signal.mjs';
+import { captureSignal } from './capture-signal.mjs';
+
 // Shared across initial capture, navigation, mergeinfo and final verification.
-export function createSvnCaptureBudget(signal){
- const deadline=captureSignal(signal);let commands=0,metadataBytes=0,bodyBytes=0;
- const error=message=>Object.assign(new Error(message),{code:'SVN_CAPTURE_BUDGET'});
- return Object.freeze({signal:deadline,reserve(){deadline.throwIfAborted();commands++;},charge(size,body=false){deadline.throwIfAborted();if(!Number.isSafeInteger(size)||size<0)throw error('Invalid SVN capture byte charge');if(body){bodyBytes+=size;if(bodyBytes>16*1024*1024)throw error('SVN capture shared verification body budget exceeded');}else{metadataBytes+=size;if(metadataBytes>1024*1024)throw error('SVN capture shared metadata budget exceeded');}},usage(){return {commands,metadataBytes,bodyBytes};}});
+export function createSvnCaptureBudget(signal) {
+  const deadline = captureSignal(signal);
+  let commands = 0, metadataBytes = 0, bodyBytes = 0;
+  const budgetError = message => Object.assign(new Error(message), { code: 'SVN_CAPTURE_BUDGET' });
+  return Object.freeze({
+    signal: deadline,
+    reserve() { deadline.throwIfAborted(); commands++; },
+    charge(size, body = false) {
+      deadline.throwIfAborted();
+      if (!Number.isSafeInteger(size) || size < 0) throw budgetError('Invalid SVN capture byte charge');
+      if (body) {
+        bodyBytes += size;
+        if (bodyBytes > 16 * 1024 * 1024) throw budgetError('SVN capture shared verification body budget exceeded');
+      } else {
+        metadataBytes += size;
+        if (metadataBytes > 1024 * 1024) throw budgetError('SVN capture shared metadata budget exceeded');
+      }
+    },
+    usage() { return { commands, metadataBytes, bodyBytes }; },
+  });
 }

package/src/svn-effective-mergeinfo.mjs

@@ -1,46 +1,68 @@
-import {hash,relativePath} from './content.mjs';
-import {mergeinfoNavigation} from './svn-mergeinfo.mjs';
-const notice='Effective property navigation within the evidenced ancestor boundary only; not merge attribution, reviewed revision coverage, permission to read branch bodies, or proof of merge execution.';
+import { hash, relativePath } from './content.mjs';
+import { mergeinfoNavigation } from './svn-mergeinfo.mjs';
+
+const NOTICE = 'Effective property navigation within the evidenced ancestor boundary only; not merge attribution, reviewed revision coverage, permission to read branch bodies, or proof of merge execution.';
 
 // records are nearest-first and complete from target to the declared boundary.
 // present:false is proven absence; missing records must never mean absent.
-export function effectiveMergeinfo(target,records,{boundary='.',complete=false}={}){
- if(target!=='.')relativePath(target);if(boundary!=='.')relativePath(boundary);
- if(boundary!=='.'&&target!==boundary&&!target.startsWith(boundary+'/'))throw new Error('Mergeinfo boundary is not an ancestor');
- const unknown=reason=>({status:'unknown',reason,sources:[],notice});
- if(!Array.isArray(records)||records.length>33)return unknown('Ancestor evidence missing or depth limit exceeded');
- let cursor=target;const evidence=[];
- for(const record of records){
-  if(!record||record.path!==cursor||typeof record.present!=='boolean'||typeof record.identity!=='string'||!record.identity)return unknown('Incomplete or unordered ancestor provenance');
-  if(record.present&&typeof record.value!=='string')return unknown('Mergeinfo value is not captured text');
-  evidence.push({path:cursor,identity:record.identity,present:record.present,...(record.present?{propertyHash:hash(record.value)}:{})});
-  if(record.present){
-   const parsed=mergeinfoNavigation(record.value);if(parsed.status!=='parsed')return {...parsed,evidence,notice};
-   const inherited=cursor!==target,suffix=cursor==='.'?(target==='.'?'':target):target.slice(cursor.length+1);
-   const sources=parsed.sources.map(source=>({sourcePath:inherited?(source.sourcePath==='/'?'':source.sourcePath)+'/'+suffix:source.sourcePath,ranges:source.ranges.filter(range=>!inherited||range.inheritable)})).filter(source=>source.ranges.length);
-   if(sources.some(s=>s.sourcePath.length>1024))return {status:'limited',reason:'Inherited mergeinfo source path limit exceeded',sources:[],evidence,notice};
-   return {status:'parsed',origin:cursor,inherited,explicitEmpty:record.value==='',sources,evidence,hash:hash(JSON.stringify(evidence)),notice};
+export function effectiveMergeinfo(target, records, { boundary = '.', complete = false } = {}) {
+  if (target !== '.') relativePath(target);
+  if (boundary !== '.') relativePath(boundary);
+  if (boundary !== '.' && target !== boundary && !target.startsWith(boundary + '/')) throw new Error('Mergeinfo boundary is not an ancestor');
+
+  const unknown = reason => ({ status: 'unknown', reason, sources: [], notice: NOTICE });
+  if (!Array.isArray(records) || records.length > 33) return unknown('Ancestor evidence missing or depth limit exceeded');
+
+  let cursor = target;
+  const evidence = [];
+  for (const record of records) {
+    if (!record || record.path !== cursor || typeof record.present !== 'boolean' || typeof record.identity !== 'string' || !record.identity) return unknown('Incomplete or unordered ancestor provenance');
+    if (record.present && typeof record.value !== 'string') return unknown('Mergeinfo value is not captured text');
+    evidence.push({ path: cursor, identity: record.identity, present: record.present, ...(record.present ? { propertyHash: hash(record.value) } : {}) });
+
+    if (record.present) {
+      const parsed = mergeinfoNavigation(record.value);
+      if (parsed.status !== 'parsed') return { ...parsed, evidence, notice: NOTICE };
+      const inherited = cursor !== target;
+      const suffix = cursor === '.' ? (target === '.' ? '' : target) : target.slice(cursor.length + 1);
+      const sources = parsed.sources
+        .map(source => ({
+          sourcePath: inherited ? (source.sourcePath === '/' ? '' : source.sourcePath) + '/' + suffix : source.sourcePath,
+          ranges: source.ranges.filter(range => !inherited || range.inheritable),
+        }))
+        .filter(source => source.ranges.length);
+      if (sources.some(s => s.sourcePath.length > 1024)) return { status: 'limited', reason: 'Inherited mergeinfo source path limit exceeded', sources: [], evidence, notice: NOTICE };
+      return { status: 'parsed', origin: cursor, inherited, explicitEmpty: record.value === '', sources, evidence, hash: hash(JSON.stringify(evidence)), notice: NOTICE };
+    }
+
+    if (cursor === boundary) {
+      if (!complete) return { ...unknown('Ancestor boundary does not prove repository-wide absence'), evidence, hash: hash(JSON.stringify(evidence)) };
+      return { status: 'parsed', origin: null, inherited: false, sources: [], evidence, hash: hash(JSON.stringify(evidence)), notice: NOTICE };
+    }
+    if (cursor === '.') return unknown('Declared ancestor boundary was not reached');
+    cursor = cursor.includes('/') ? cursor.slice(0, cursor.lastIndexOf('/')) : '.';
   }
-  if(cursor===boundary){if(!complete)return {...unknown('Ancestor boundary does not prove repository-wide absence'),evidence,hash:hash(JSON.stringify(evidence))};return {status:'parsed',origin:null,inherited:false,sources:[],evidence,hash:hash(JSON.stringify(evidence)),notice};}
-  if(cursor==='.')return unknown('Declared ancestor boundary was not reached');
-  cursor=cursor.includes('/')?cursor.slice(0,cursor.lastIndexOf('/')):'.';
- }
- return unknown('Ancestor evidence ended before nearest explicit property or boundary');
+  return unknown('Ancestor evidence ended before nearest explicit property or boundary');
 }
 
 // Injected reader must freeze UUID/URL/peg/operative revision and charge its
 // existing command/metadata budget. This helper never reads branch bodies.
-export async function captureEffectiveMergeinfo(target,{read,signal,boundary='.',complete=false}={}){
- if(typeof read!=='function')throw new Error('Fixed ancestor property reader required');
- if(target!=='.')relativePath(target);if(boundary!=='.')relativePath(boundary);
- if(boundary!=='.'&&target!==boundary&&!target.startsWith(boundary+'/'))throw new Error('Mergeinfo boundary is not an ancestor');
- const records=[];let cursor=target;
- for(let depth=0;depth<33;depth++){
-  signal?.throwIfAborted();const record=await read(cursor);signal?.throwIfAborted();
-  if(record?.path!==cursor)throw new Error('Mergeinfo ancestor reader identity mismatch');records.push(record);
-  if(record.present||cursor===boundary)return effectiveMergeinfo(target,records,{boundary,complete});
-  if(cursor==='.')throw new Error('Mergeinfo ancestor boundary not reached');
-  cursor=cursor.includes('/')?cursor.slice(0,cursor.lastIndexOf('/')):'.';
- }
- return {status:'limited',reason:'Mergeinfo ancestor depth limit exceeded',sources:[],notice};
+export async function captureEffectiveMergeinfo(target, { read, signal, boundary = '.', complete = false } = {}) {
+  if (typeof read !== 'function') throw new Error('Fixed ancestor property reader required');
+  if (target !== '.') relativePath(target);
+  if (boundary !== '.') relativePath(boundary);
+  if (boundary !== '.' && target !== boundary && !target.startsWith(boundary + '/')) throw new Error('Mergeinfo boundary is not an ancestor');
+  const records = [];
+  let cursor = target;
+  for (let depth = 0; depth < 33; depth++) {
+    signal?.throwIfAborted();
+    const record = await read(cursor);
+    signal?.throwIfAborted();
+    if (record?.path !== cursor) throw new Error('Mergeinfo ancestor reader identity mismatch');
+    records.push(record);
+    if (record.present || cursor === boundary) return effectiveMergeinfo(target, records, { boundary, complete });
+    if (cursor === '.') throw new Error('Mergeinfo ancestor boundary not reached');
+    cursor = cursor.includes('/') ? cursor.slice(0, cursor.lastIndexOf('/')) : '.';
+  }
+  return { status: 'limited', reason: 'Mergeinfo ancestor depth limit exceeded', sources: [], notice: NOTICE };
 }

package/src/svn-eol-mapping.mjs

@@ -1,13 +1,25 @@
-import {hash} from './content.mjs';
+import { hash } from './content.mjs';
 
 // Keep raw text as evidence. LF view is metadata only, never a source replacement.
-export function svnEolMapping(text,style=null){
- if(typeof text!=='string'||Buffer.byteLength(text)>256*1024||!(style===null||['native','LF','CRLF','CR'].includes(style)))throw new Error('Unsupported SVN EOL mapping input or style');
- let crlf=0,lf=0,cr=0;
- for(let i=0;i<text.length;i++){
-  if(text[i]==='\r'){if(text[i+1]==='\n'){crlf++;i++;}else cr++;}
-  else if(text[i]==='\n')lf++;
- }
- const normalized=text.replace(/\r\n|\r/g,'\n');
- return {rawTextHash:hash(text),lfViewHash:hash(normalized),style,counts:{crlf,lf,cr},mixed:[crlf,lf,cr].filter(Boolean).length>1,lineMapping:cr?'not-identity-for-LF-evidence':'identity',notice:'Hashes describe decoded text encoded as UTF-8, not original source bytes. LF-view hash only; raw text and raw evidence line numbering remain authoritative. Lone CR changes LF line boundaries; do not use normalized line numbers. Newline-only differences do not independently prove a defect or runtime equivalence.'};
+const ALLOWED_STYLES = [null, 'native', 'LF', 'CRLF', 'CR'];
+
+export function svnEolMapping(text, style = null) {
+  if (typeof text !== 'string' || Buffer.byteLength(text) > 256 * 1024 || !ALLOWED_STYLES.includes(style)) throw new Error('Unsupported SVN EOL mapping input or style');
+  let crlf = 0, lf = 0, cr = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === '\r') {
+      if (text[i + 1] === '\n') { crlf++; i++; }
+      else cr++;
+    } else if (text[i] === '\n') lf++;
+  }
+  const normalized = text.replace(/\r\n|\r/g, '\n');
+  return {
+    rawTextHash: hash(text),
+    lfViewHash: hash(normalized),
+    style,
+    counts: { crlf, lf, cr },
+    mixed: [crlf, lf, cr].filter(Boolean).length > 1,
+    lineMapping: cr ? 'not-identity-for-LF-evidence' : 'identity',
+    notice: 'Hashes describe decoded text encoded as UTF-8, not original source bytes. LF-view hash only; raw text and raw evidence line numbering remain authoritative. Lone CR changes LF line boundaries; do not use normalized line numbers. Newline-only differences do not independently prove a defect or runtime equivalence.',
+  };
 }

package/src/svn-history-endpoints.mjs

@@ -1,15 +1,21 @@
-import {relativePath} from './content.mjs';
-import {assertNonSecretPath} from './secret-path.mjs';
+import { relativePath } from './content.mjs';
+import { assertNonSecretPath } from './secret-path.mjs';
 
 // Cross-branch endpoints are repository-relative paths, never arbitrary URLs.
-export function svnHistoryEndpoints(local,options,destination){
- const hasBase=options.svnBasePath!==undefined,hasTarget=options.svnTargetPath!==undefined;
- if(hasBase!==hasTarget)throw new Error('SVN branch comparison requires both svnBasePath and svnTargetPath');
- if(!hasBase)return {baseUrl:destination(local.url,options.svnAllowNetwork).url,targetUrl:destination(local.url,options.svnAllowNetwork).url,crossUrl:false};
- if(options.svnRevision!==undefined)throw new Error('SVN branch paths require explicit revision range');
- if(!local.repository?.root||!local.repository?.uuid)throw new Error('SVN repository root identity required');
- const endpoint=value=>{if(value!=='.'){relativePath(value);assertNonSecretPath(value);}const root=destination(local.repository.root,options.svnAllowNetwork).url;return value==='.'?root:root+'/'+value.split('/').map(encodeURIComponent).join('/');};
- const baseUrl=endpoint(options.svnBasePath),targetUrl=endpoint(options.svnTargetPath);
- if(baseUrl!==targetUrl&&(baseUrl.startsWith(targetUrl+'/')||targetUrl.startsWith(baseUrl+'/')))throw new Error('Overlapping SVN branch roots require unambiguous endpoint path mapping');
- return {baseUrl,targetUrl,crossUrl:baseUrl!==targetUrl};
+export function svnHistoryEndpoints(local, options, destination) {
+  const hasBase = options.svnBasePath !== undefined, hasTarget = options.svnTargetPath !== undefined;
+  if (hasBase !== hasTarget) throw new Error('SVN branch comparison requires both svnBasePath and svnTargetPath');
+  if (!hasBase) return { baseUrl: destination(local.url, options.svnAllowNetwork).url, targetUrl: destination(local.url, options.svnAllowNetwork).url, crossUrl: false };
+  if (options.svnRevision !== undefined) throw new Error('SVN branch paths require explicit revision range');
+  if (!local.repository?.root || !local.repository?.uuid) throw new Error('SVN repository root identity required');
+
+  const endpoint = value => {
+    if (value !== '.') { relativePath(value); assertNonSecretPath(value); }
+    const root = destination(local.repository.root, options.svnAllowNetwork).url;
+    return value === '.' ? root : root + '/' + value.split('/').map(encodeURIComponent).join('/');
+  };
+
+  const baseUrl = endpoint(options.svnBasePath), targetUrl = endpoint(options.svnTargetPath);
+  if (baseUrl !== targetUrl && (baseUrl.startsWith(targetUrl + '/') || targetUrl.startsWith(baseUrl + '/'))) throw new Error('Overlapping SVN branch roots require unambiguous endpoint path mapping');
+  return { baseUrl, targetUrl, crossUrl: baseUrl !== targetUrl };
 }

package/src/svn-history-lookup.mjs

@@ -1,31 +1,39 @@
 import path from 'node:path';
-import {relativePath} from './content.mjs';
+import { relativePath } from './content.mjs';
+
+const REVISION = /^(0|[1-9][0-9]*)$/;
 
 // A successful immediate-parent listing proves absence within the visible scope.
 // Access errors are propagated, not interpreted using stderr or localized text.
-export function fixedSvnLookup({list,signal,maxEntries=512}={}) {
- if(typeof list!=='function'||!Number.isSafeInteger(maxEntries)||maxEntries<1||maxEntries>512)throw new Error('Invalid SVN historical lookup capability');
- const directories=new Map();let entries=0;
- const lookup=async(name,revision,side)=>{
-  relativePath(name);signal?.throwIfAborted();
-  if(typeof revision!=='string'||!/^(0|[1-9][0-9]*)$/.test(revision)||!Number.isSafeInteger(Number(revision)))throw new Error('Invalid SVN lookup revision');
-  const parent=path.posix.dirname(name),key=JSON.stringify([side??null,revision,parent]);
-  if(!directories.has(key)){
-   if(parent!=='.'){
-    const node=await lookup(parent,revision,side);
-    if(!node||node.kind!=='dir')return null;
-   }
-   const records=await list(parent,revision,side);signal?.throwIfAborted();
-   if(!Array.isArray(records))throw new Error('Invalid fixed SVN directory listing');
-   const children=new Map();
-   for(const record of records){
-    if(++entries>maxEntries)throw new Error('SVN historical directory entry budget exceeded');
-    if(typeof record?.name!=='string'||record.name.includes('/')||relativePath(record.name)!==record.name||!['file','dir'].includes(record.kind)||children.has(record.name))throw new Error('Invalid fixed SVN directory entry');
-    children.set(record.name,{kind:record.kind});
-   }
-   directories.set(key,children);
-  }
-  return directories.get(key).get(path.posix.basename(name))??null;
- };
- return {lookup,usage:()=>({directories:directories.size,entries})};
+export function fixedSvnLookup({ list, signal, maxEntries = 512 } = {}) {
+  if (typeof list !== 'function' || !Number.isSafeInteger(maxEntries) || maxEntries < 1 || maxEntries > 512) throw new Error('Invalid SVN historical lookup capability');
+  const directories = new Map();
+  let entries = 0;
+
+  const lookup = async (name, revision, side) => {
+    relativePath(name);
+    signal?.throwIfAborted();
+    if (typeof revision !== 'string' || !REVISION.test(revision) || !Number.isSafeInteger(Number(revision))) throw new Error('Invalid SVN lookup revision');
+    const parent = path.posix.dirname(name);
+    const key = JSON.stringify([side ?? null, revision, parent]);
+    if (!directories.has(key)) {
+      if (parent !== '.') {
+        const node = await lookup(parent, revision, side);
+        if (!node || node.kind !== 'dir') return null;
+      }
+      const records = await list(parent, revision, side);
+      signal?.throwIfAborted();
+      if (!Array.isArray(records)) throw new Error('Invalid fixed SVN directory listing');
+      const children = new Map();
+      for (const record of records) {
+        if (++entries > maxEntries) throw new Error('SVN historical directory entry budget exceeded');
+        if (typeof record?.name !== 'string' || record.name.includes('/') || relativePath(record.name) !== record.name || !['file', 'dir'].includes(record.kind) || children.has(record.name)) throw new Error('Invalid fixed SVN directory entry');
+        children.set(record.name, { kind: record.kind });
+      }
+      directories.set(key, children);
+    }
+    return directories.get(key).get(path.posix.basename(name)) ?? null;
+  };
+
+  return { lookup, usage: () => ({ directories: directories.size, entries }) };
 }

package/src/svn-keyword-config.mjs

@@ -1,10 +1,13 @@
 // Native SVN separates keyword definitions using ASCII whitespace, not shell quotes.
-export function keywordConfigurationTokens(configuration){
- if(typeof configuration!=='string'||Buffer.byteLength(configuration)>4096)throw new Error('Invalid SVN keyword configuration');
- if(configuration.includes(String.fromCharCode(34))||configuration.includes(String.fromCharCode(39)))throw new Error('Quoted SVN keyword configurations are unsupported; use %_ for a space');
- if(/[\x00-\x08\x0e-\x1f\x7f]/.test(configuration))throw new Error('Control character in SVN keyword configuration');
- if(configuration.includes(String.fromCharCode(92)))throw new Error('Unquoted escape in SVN keyword configuration');
- const tokens=configuration.split(/[ \t\r\n\v\f]+/).filter(Boolean);
- if(tokens.length>100)throw new Error('SVN keyword configuration token limit exceeded');
- return tokens;
+const CONTROL_CHARS = /[\x00-\x08\x0e-\x1f\x7f]/;
+const WHITESPACE = /[ \t\r\n\v\f]+/;
+
+export function keywordConfigurationTokens(configuration) {
+  if (typeof configuration !== 'string' || Buffer.byteLength(configuration) > 4096) throw new Error('Invalid SVN keyword configuration');
+  if (configuration.includes(String.fromCharCode(34)) || configuration.includes(String.fromCharCode(39))) throw new Error('Quoted SVN keyword configurations are unsupported; use %_ for a space');
+  if (CONTROL_CHARS.test(configuration)) throw new Error('Control character in SVN keyword configuration');
+  if (configuration.includes(String.fromCharCode(92))) throw new Error('Unquoted escape in SVN keyword configuration');
+  const tokens = configuration.split(WHITESPACE).filter(Boolean);
+  if (tokens.length > 100) throw new Error('SVN keyword configuration token limit exceeded');
+  return tokens;
 }